package hello.world;
//最多只能够有一个pubilc 的类，其他的类个数不限，就对应多少个class文件
//class类后面的的类名字更你的文件名字是一致的，注意这一点
//{}内的内容就叫做类体
public class HelloWorld {
static int ii=1000; //在类体里面的叫成员变量，且必须在前面加上static
public static void main(String[] args) { //小括号里面的叫方法
// TODO code application logic here //小括号后面的{}叫方法体
int i=100; //在方法体内的叫局部变量 出了大括号就没人认识它的
long a=88888888L; //默认是int型，后面必须加L
double b=123.865; //double默认是0.0
long b2=300000001L;
float j=12.3f; //默认是double类型，加f，Java是没用无符号的整数类型的，byte shor int long
byte b1=(byte)(i+b);
char c1 ='n'; //注意的是在Java的char字符型数据类型中，是unicode的编码 每个字符占用连个字节，且\u可以转译为其他含义字符
String s ="Hello";
System.out.println("Hello World!");
System.out.println(a);
System.out.println("b2="+b2);
System.out.println("b1="+b1); //这是内部内存直接砍掉之后的剩下多少就是多少。啃定是不正确的
System.out.println("i="+(i+b)+"第三个就是"); //注意这个第一个+是语句执行的加法,但是如果就是加上一个括号就是加法运算
System.out.println(ii);
}
}
class T{
public static void TT(String [] args) {
int iii=109;
System.out.println(iii);
}
}
学习笔记：
1、print与println是不一样的，print是不换行的，而printin是打印后自动换行的
2、| & 和 || &&没有区，只是运算过程不一样
3、+ 还可以是字符串连接符 string“Hello”+“Word。
规则“System。Output""c="+c" 自动转换位字符串打印出来
4、Java在循环语句中在Switch中只会是识别int类型的参数，其他一律不执行
5、Java里面的方法其实就是其它语言的函数，习惯叫方法，可以像其他函数一样被调用
6、有且只有一个public static void main(String[] args）
7、java函数床底函数的过程规则是：参数类型一致，反回来类型也一致
pubilc static void mian (string[] args) {
a(); //表示调用方法a（）；
}
pubilc static void a() { }
pubilc static void b() {
return； //一旦就是用了return，二话不说直接停止这个方法后面的语句，直接返回主函数
}
pubilc static void m3(int i,int j)
pubilc static int m4 (int i,int j)//返回的值储存在一个临时开开辟的空间内存里面，你可以用可以不用，它会自动重收内存
8、递归函数的应用
递归含义：在函数里面调用函数本身，在方法里面调用自己的方法，所以牛只要给他一个终止的命令指令在前面即可
if（n==1）
return 1;
else return meth(n-1) ; //不要满足推出终止指令循环执行，一旦到了终止既终止
面向对象的编程语言
面向过程：我要去新疆，我开车，我启动汽车，我踩油门，我过山西，我过湖南，我到了新疆
面对对象：我要去新疆，车你去新疆吧，怎么去？我不管，我到了新疆
9、合适的方法要出现在合适的类里面，只要给出合适的 接口 就行
10、在你编程你的时候就不要一步一步的来了，更注重是对象的关系
11、类 是抽象出来的并没有准确的定义，对象 是类里面的具体的特征关系 瓶子 是一个类，某个瓶子就是一个对象，一个类可以对应多个类
12、关系和关系 之间是不同的
关联关系，
继承关系（继承树）（XX是一种XX，如：学生是一个人，篮球运动员是运动员），
聚合关系（聚集（一般） 和 组合（严格），（整体和部分）
实现关系 （就是 实现 的方法，虽然是 继承关系，但各自有自己的子类去实现，子实现方法是不一样的
13、面向对象的思维
第一步：有什么类有几个对象
第二步：这些类和对象具有什么属性和方法
第三步：具有什么的具体关系
14、Java的语法
//用class定义一个类
class Person{
//成员变量的定义
private int id ;
private int age = 20;
//方法的定义
pubilc int getAge（）{ return age ；}
pubilc void setAge（int i）{ age = i ； }
}
15、成员变量可以不用初始化，Java可以直接调用，但是局部变量没有初始化是不能运行的!!!
16、基本类型在内存中占一块，而引用类型在内存中占用两块
String s；//申明了一个类的变量名称，但是没有具体的对象
s = new String （“Hello World”）；//到这里才是真正定义了一个类的具体对象属性
17、构造方法，名字和类名字一样且没有没有返回值、 也灭有返回值类型
pubilc class Person{
int id;
int age;
//构造函数，如果就是你不在后面添加构造方法 系统将自动为你添加一个空的构造方法 Person （）{ }
Person （int n，int i）{
+
id=n；
age=i；
}
} //构造方法和new一起使用 建立一个对象
18、方法重载：就是预留一个接口可提供调用时候时可以使用不同的方法名称，而函数内用基本一致，避免复杂重新写程序
void max(int a,int b) {System.out.printiln(a>b?a:b}
前面用的构造方法也可以构成重载方法！ 符合API接口的人性化
19、package hello.world;
class Point {
private double x;
private double y;
Point(double x1, double y1) {
x = x1;
y = y1;
}
public double getX() { return x; }
public double getY() { return y; }
public void setX(double i) { x = i; }
public void setY(double i) { y = i; }
}
class Circle {
private Point o;
private double radius;
Circle(Point p, double r) {
o = p;
radius = r;
}
Circle(double r) {
o = new Point(0.0, 0.0);
radius = r;
}
boolean contains(Point p) {
double x = p.getX() - o.getX();
double y = p.getY() - o.getY();
if(x*x + y*y > radius * radius) return false;
else return true;
}
public void setO(double x, double y) {
o.setX(x);
o.setY(y);
}
public Point getO() { return o; }
public double getRadius() { return radius;}
public void setRadius(double r) { radius = r;}
public double area() {
return 3.14 * radius * radius;
}
}
public class HelloWorld {
public static void main(String args[]) {
Circle c1 = new Circle(new Point(1.0,2.0), 2.0);
Circle c2 = new Circle(5.0);
System.out.println("c1:("+c1.getO().getX()+","
+c1.getO().getY()+"),"+c1.getRadius());
System.out.println("c2:("+c2.getO().getX()
+","+c2.getO().getY()+"),"+c2.getRadius());
System.out.println("c1 area = "+c1.area());
System.out.println("c1 area = "+c2.area());
c1.setO(5,6);
c2.setRadius(9.0);
System.out.println("c1:("+c1.getO().getX()+","
+c1.getO().getY()+"),"+c1.getRadius());
System.out.println("c2:("+c2.getO().getX()+","
+c2.getO().getY()+"),"+c2.getRadius());
System.out.println("c1 area = "+c1.area());
System.out.println("c1 area = "+c2.area());
Point p1 = new Point(5.2, 6.3);
System.out.println(c1.contains(p1));
System.out.println(c1.contains(new Point(10.0,9.0)));
}
}
以上代码是对从开始到学完new关键字的总结，必须手打一边带代码，真正理解堆和栈内存的分析，掌握内存就掌握一切，以及new在各个语法的可应用型
20、以下是关键字this 指向自身的对象引用，看内存指向自己，同时可以区分参数和实参的关系（就近申明原则）
21、static 关键字 static成员变量只有一份，且在一个类里面共享一个static变量（存放在数据区data seg），区别于非静态成员变量他是共享的，int是每一个对象都有的
22、static直接使用是 类名.(static), 而不是 对象名.(int)
23、super关键字： class ChildClass extends FatherClass {} 在childclass对象cc里面那还有一个父类对象
24、supper与this相似，指向父类对象this value 以及 super.value 与this用法相同
25、final关键字：final的变量值不能重写不能改变不能继承，与super重写作用相反 final int i =9 ；只可以读不可以写
26、package（机制） 和 import语句 写在第一条语句 包的问题 提供多类重命名的空间 package com.bjsxt.java -->又左往右包
27、public 权限修饰符 还有 private default protected
28、继承：extends 子类自动就有了基类，就是共用了的一个类，狗是动物猫也是动物，Java只支持一种继承就是只有一个类，c++支持多个类
29、继承中有权限 可以有所有权，当时没有使用权
30、子类的狗找方法必须调用父类的狗找方法，就是在后面加上super（int x） 或者使用 this（int x） 如果调用了super必须些写在钩爪方法的第一行
31、如果就是没有调用父类的钩爪方法那么就自动调用使用空参数父类那条，在没有空参数的语句，那么就是编译出错
package hello.world;
class Person{
private String name;
private int years;
private double money;
Person(String name,int years,double money){
this.name = name;
this.years = years;
this.money = money;
System.out.println("姓名：" + name + " 年龄： " + years + " 工资： " + money);
}
}
class Teacher extends Person{
String profession;
public Teacher(String profession) {
super("Caden",25,2546.3);
this.profession = profession;
System.out.println("担任职位：" + profession);
}
public void infoTeacher(){
}
}
public class HelloWorld {
public static void main(String args[]) {
Teacher Caden = new Teacher("财务主任");
}
}
运行结果：
姓名：Caden 年龄： 25 工资： 2546.3
担任职位：财务主任
成功构建 (总时间: 0 秒)
32、重写：从父类继承下来的方法不满意，重新写一遍，狗在跑你却说动物在跑
33、Object类是Java的老祖宗，不用写明就可调用了
34、 to String方法 可以根据需要重写to String 方法
Dog d = new Dog();
System.out.print(d.toString());
35、equals方法 直接比较只能比较地址，而使用equals可以直接比较性质
class Dog{
int name;
int color;
Dog(int name,int color ) {
this.name = name;
this.color = color;
}
/* 这个是类包里面的对toString的方法的修改
public String toString(){
return "my name is Caden ";
}*/
/*这里是对eqals类包的修改，因为你不满意可所以我们要修改
public boolean equals(Object obj){
if(obj == null){
return false;
}
else{
if(obj instanceof Dog){
Dog d =(Dog)obj;
if(d.color == this.color && d.name == this.name) return true;
}
}
return false;
}*/
}
public class HelloWorld{
public static void main(String[] args) {
Dog d1 = new Dog(1,3);
Dog d2 = new Dog(1,3);
System.out.println(d1 == d2);
System.out.println(d1.equals(d2));
}
}
36、对象转型（casting）向上转型up 向下转型dowm
37、动态绑定（多态），在执行期间根据所需的实际类型进行调用相应的啊方法。
abstract class Animal {
private String name;
Animal(String name) {this.name = name;}
public void enjoy(){
System.out.println("叫声......");
}
//public abstract void enjoy();
}
class Cat extends Animal {
private String eyesColor;
Cat(String n,String c) {super(n); eyesColor = c;}
public void enjoy() {
System.out.println("猫叫声......");
}
//public abstract void enjoy();
}
class Dog extends Animal {
private String furColor;
Dog(String n,String c) {super(n); furColor = c;}
public void enjoy() {
System.out.println("狗叫声......");
}
}
class Bird extends Animal {
Bird() {
super("bird");
}
public void enjoy() {
System.out.println("鸟叫声......");
}
}
class Lady {
private String name;
private Animal pet;
Lady(String name,Animal pet) {
this.name = name; this.pet = pet;
}
public void myPetEnjoy(){pet.enjoy();}
}
public class Test {
public static void main(String args[]){
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname","black");
Bird b = new Bird();
//Lady l1 = new Lady("l1",c);
Lady l2 = new Lady("l2",d);
Lady l3 = new Lady("l3",b);
//l1.myPetEnjoy();
l2.myPetEnjoy();
l3.myPetEnjoy();
}
}
38、abstract 抽象类和抽象方法 只有定义没有实现，就是说你只要定义就行了 public void enjoy(){} == public abstract void enjoy(){} 就是说这个方法就是等着被重写的
一旦你定义为抽象 俺么你一定就要重写
39、接口：一种特殊的抽象类，抽线方法和常量的集合 public interface Runner{} 没有变量也没有具体实现的方法 你只需要有一个final的定义常量以及一个方法的函数明就ok
金丝猴是一个动物，动物是一个父类 同时金丝猴也是一个值钱的东西 值钱的东西也是一个父类 interface implement
想同时继承两个父类，不行Java的extends一个 子类只支持继承一个父类 所以引用接口的概念
一个类可以实现多继承了，接口还可以继承其他的接口class Teacher implemet Sing,Painter{}
public interface Valuable {
public double getMoney();
}
interface Protectable {
public void beProtected();
}
interface A extends Protectable {
void m();
void getMoney();
}
abstract class Animal {
private String name;
abstract void enjoy();
}
class GoldenMonkey extends Animal implements Valuable, Protectable {
public double getMoney() {
return 10000;
}
public void beProtected() {
System.out.println("live in the room");
}
public void enjoy() {
}
public void test() {
Valuable v = new GoldenMonkey();
v.getMoney();
Protectable p = (Protectable)v;
p.beProtected();
}
}
class Hen implements A {
public void m() {}
public void beProtected() {}
public double getMoney() {
return 1.0;
}
public void getMoney() {}
}
异常处理，就是常见的错误进行修正
40、关键字 try 尝试这条语句 catch捕获异常 try后面可以跟上多个catch语句一对多；一个catch只能对应一种类型的异常
catch语句先写小的再写大的
41、 int[] arr = {1, 2, 3};
System.out.println(arr[2]);
try {
System.out.println(2/0);
} catch (ArithmeticException e) { 抓住上面2/0的错误，因为你一斤出错的(ArithmeticException 是一个类，有系统自动长产生
System.out.println("系统正在维护,请与管理员联系");
e.printStackTrace(); 把错误的堆栈打印出来 因为它可能是由上一个错误打印来
}
42、就是提供用户的出错的提示，生成一个出错的类 在把你显示出来
这个功能就是做到错错人性化，不想C语言的要程序员自己找错
43、throws关键字 可能抛出的程序条件 就是说怕你子啊thows里面写得代价吗就是可能会出错的，而出错的时候就会可以根据你写的东西 显示出到底是什么错误
只要你有错误的Exception我就可以抛出去，出错了我不处理，交给上级
void m(int i) throws ArithmeticException {
if(i==0)
throw new ArithmeticException("被除数为0"); 创建一个新的类，里面的参数是“String”交给系统
}
44、 thowsable 可抛出的
| |
Error（系统的不可处理） Exception（可处理的）
| | | |
其他 其他 RuntimeException（经常出的错误，你可以不处理的）
还有就是不是经常出的错误，那么你一定就要用Catch把他逮住，然后thows出去
45、finally语句：作用提供统一的出口，是的抛出程序复原，如果没有finally -> 跑飞，还 关闭临时文件，清楚过程垃圾
try{ .....语句1 (语句1出错 语句2不可能执行) 语句2......}
| ————————————————————————>>
catch (SomeException_1 se) { ......... 处理的语句 ..........} |
. |
catch (SomeException_2 se) { ......... 处理的语句 ..........} |
| <<———————————————————————
finally { ...无论你是执行了几个catch语句，最后都会经过finally语句后跳出出错内存... }
46、注意就是： 在类继承的重写方法里面所抛出的异常类型必须与原方法的抛出类型一致
不同的不行，大了也不行，但是你可以不抛异常，可以抛。
47、数组申明：type var[]; 或者 type[] var; 也像 c一样就是 int double short
48、数组有动态初始化（分开赋值）和静态初始化（定义时候就赋值）：
49、int[] a = {2, 4, 6, 7, 3, 5, 1, 9, 8};
int [] aa = new int[3];
System.out.println(aa[1]);
50、经过实验指导在Java中，你所定义的宿主必须是全部都给赋值了，不能有空的数组，不然会报错
51、Integer.parseInt(args[i]) 把字符数组转换为int类型
public class TestDateSort {
public static void main(String[] args) {
Date[] days = new Date[5];
days[0] = new Date(2006, 5, 4);
days[1] = new Date(2006, 7, 4);
days[2] = new Date(2008, 5, 4);
days[3] = new Date(2004, 5, 9);
days[4] = new Date(2004, 5, 4);
Date d = new Date(2006, 7, 4);
String str = String.valueOf(d);
//str = d.toString();
bubbleSort(days);
for(int i=0; i<days.length; i++) {
System.out.println(days[i]);
}
System.out.println(binarySearch(days, d));
}
public static Date[] bubbleSort(Date[] a){
int len = a.length;
for(int i = len-1;i>=1;i--){
for(int j = 0;j<=i-1;j++){
if(a[j].compare(a[j+1]) > 0){
Date temp = a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
return a;
}
public static int binarySearch(Date[] days, Date d) {
if (days.length==0) return -1;
int startPos = 0;
int endPos = days.length-1;
int m = (startPos + endPos) / 2;
while(startPos <= endPos){
if(d.compare(days[m]) == 0) return m;
if(d.compare(days[m]) > 0) {
startPos = m + 1;
}
if(d.compare(days[m]) < 0) {
endPos = m -1;
}
m = (startPos + endPos) / 2;
}
return -1;
}
}
class Date {
int year, month, day;
Date(int y, int m, int d) {
year = y; month = m; day = d;
}
public int compare(Date date) {
return year > date.year ? 1
: year < date.year ? -1
: month > date.month ? 1
: month < date.month ? -1
: day > date.day ? 1
: day < date.day ? -1 : 0;
}
public String toString() {
return "Year:Month:Day -- " + year + "-" + month + "-" + day;
}
}
52、在Java中的常用类，
比如有String类，就是在基础的底层里面它提供了比较方便的类调用方法给你们让你进行调用，从而简化了程序，他有很多String.xxx,具体可以查询API文档
53、StringBuffer类
可辨的字符序列 StringBuffer（）创建一个空的字符缓冲 StringBuffer（String str）把特定字符闯进去
String s1 ="Hello World"
String s2 = “Java” String是不可辨的字符序列就是内存不可变，StringBuffer是可变内存的字符序列 可以直接相加 s1 += s2;
public StringBuffer apend、insert、deleted
54、基础数据类型的包装类 int double Boolean
java.lang.foalt
valueOf
55、math类的举例子说明用的不多
包装了一系列的数学运算 abs绝对值
feil类的计算，java.io.feil 就是硬盘的文件名，也可以是路径明 public feil(String pathname),他会帮你创建文件 ，只要你给他制定的代码
56、enum枚举类型
publi enum myColor {red, blue, green}
myColor m = myColor.red;
第七章 容器，内容多且重要，装对象的东西就是容器，所有的东西都存储在一起。
基本概念：容器的API、Collection的接口、interator接口、增强for循环、Set接口、List接口和Comparable接口、Collection接口、colection类、Map接口、自动打包和解包、泛型。
collection
|
set（单个装，无顺序不可重复） list（单个装，有顺序可以重复） map（两个装）
对象本来就不是重复的，这里的重复是指equals的对象重复
| |
ArrayList()还有定义了各种方法
57、collection接口：Collection c = new ArrayList();
c.add("HelloWorld");
c.add(new name (&q
登录查看全部
参与评论
手机查看
返回顶部