java视频笔记（一）

RAD开发工具：

RAD：rapid application develop 快速应用开发

code 代码，密码，编码

incode 译码

segment 段，部分，分割

jre（java运行环境）

 

构造函数

1. A aa=new A();

2. 构造函数（生成函数）

3. System.out.printf(‘%d\n”,a)

4. 定义的同时直接赋值：步骤如下

先生成构造函数：public A（int a，int b）

                {

                   i=a;

                   J=b;

               System.out.printf(‘无参构造函数被调用了\n”)

}

再写A aa=new A(a，b);

5.构造函数的要求：函数的名字跟类名必须是一样的；这个函数不能有返回值（即：构造函数里面不能有void）；

对象：类的一个个体。

类是一个模型；不是一个具体的事物；

私有的属性不能在类的外部被访问，即不能通过对象名的方式被访问；

6. 构造函数数据成员的赋值问题：

java里面如果自己定义构造函数的话，它就不会提供默认的无参，需添加public A；

Boolean用%b或%B输出；

局部变量编译器是不会自动进行初始化的，java要求所有的局部变量在使用之前都必须初始化。

 

函数的重载

1. 定义：有很多个函数，它们的函数名是一样的，它们的形参列表不一样（包括个数不一样或数据类型不一样或个数一样数据类型一样但是它们的顺序不一样）。

 

this→它是基于内存分配的问题；

1.java语言中的“类”相当于C语言中的“结构体”；

2.在方法里面都包括一个this指针（说法错误），静态的就没有（因为静态的属于类本身，不属于对象）；

n个对象共用一个方法时才会出现this指针；

 

static（中文：静态的）→难理解

1.需要统计出这个类生产出多少个对象，需要用到static的知识；

2.如果在一个属性前面加一个static，意味着这个属性就不是某一个对象的了，n个对象共用同样一个属性i。

3.没有对象，我们仍然可以直接通过类名的方式访问该类内部的static属性。

4.static属性和方法虽然属于类本身，虽然可以通过类名的方式访问，但是static属性和方法很明显也属于类对象，当然也可以通过类对象名的方式访问。

如：

A aa=new A;

或A.f();

或aa.f;     //这三个运行的是一样的结果；

5.static不属于控制符，算一个修饰符；

6.只有非私有（private）的static成员才可以通过类名的方式访问；或者说static只是表明了该成员具有了可以通过类名访问的潜在特征，但是否可以通过类名访问还必须满足一个条件：该成员必须是非private。

如：private static void f（）   //这样写是不对的；

7.非静态方法可以访问静态成员；静态方法不能访问非静态成员（因为静态的时候很有可能还没有对象）；同样的，静态的可以访问静态的；

8.有静态方法的时候不一定有非静态方法；但是有非静态方法的时候，静态方法一定有了；

9.统计出A这个类能够造出几个对象出来，需要用到静态属性的例子→用这个getCnt方法；

如：public static int getCnt()

即：getCnt必须是公有的、静态的（原因：保证n个对象共用同样一个cnt，减少内存空间的分配），前面加public static；

10.静态属性前面不能加this；

static修饰的是普通方法，不能修饰构造方法；

一个类的属性可以是个类对象；

11.静态方法不能以任何方式引用this和super关键字；

12.静态方法只能访问类的静态成员，但非静态却可以访问类中所有成员，包括静态成员。

 

面向对象特性：封装、继承、多态；

printf比println功能要强大；

printf可以对一个数据进行格式化输出，而println不能；

 

继承（extends）

1.一个新类从已有的类那里获得其已有的属性和方法，这种现象叫做类的继承。

2.继承的实现方式：

Class SubClass extends SuperClass

{

.......

}

同胞继承权限问题（重点）

3.子类内部可以访问父类非私有的成员；

私有成员无法被子类方法访问；

4.通过子类对象名只能访问从父类继承过来的非私有成员；

5.总结：

私有不能被继承；

私有在物理上已经被继承过来，只不过逻辑上程序员不能去访问它，因此继承必须慎重，否则会浪费内存。

6.父类的私有成员不可以被子类继承，其它的成员都可以被子类继承；

7.继承的原则;

何时选择继承？答：“B是一个A吗？”如果是则让B做A的子类。

注：java中的继承实际上反映的是一种一般到特殊的关系；

8.java只支持单继承，不支持多重继承；单继承就是一个类只能有一个父亲；多继承就是一个类可以有多个父类；

9.子类访问父类成员的三种方式：

在子类内部访问父类成员；

通过子类对象名访问父类成员；

通过子类的类名访问父类成员；

注：子类通过上述三种方式的任何一种都无法访问父类私有成员，因此我们可以得出结果：

私有成员无法被子类继承。

例：

class A

{

public static int i;

protected static int j;

private static int k;

}

class B extends A

{

private void g()

{

i=22;

// k=20;   error

}

}

class M

{

public static void main(String[] args)

{

A.i=99;

B.i=99;

B bb=new B();

bb.i=99;

}

}

 

super

super的使用：

1.每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错；

2.如果显示的写出super();语句，则必须保证该语句是第一条语句，否则会出错；

 

3.super();如果不写，则编译器会自动添加,所以此时如果父类没有无参的构造函数就会出错；

4.既可以显示写super();前提是父类必须有无参的构造函数；也可以显示写super(实参); 前提是父类必须有带参的构造函数；

5.调用父类的构造函数的语句必须借助于super,不能直接写父类的类名，这与C++不同。

 

方法的重写：（重写父类方法）

1.重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型；

2.子类中不允许出现与父类同名同参但不同返回类型的方法，如果出现了，编译时会报错；

3.什么是重写？

答：指在子类中重新定义父类中已有的方法。

4.只有在继承的时候才会出现重写；

5.重写方法的权限不能低于被重写方法的访问权限；

例：

class A

{

public void f()

{

System.out.printf("AAAA\n");

}

}

class B extends A

{

public void f()

       {

System.out.printf("BBBB");

}

}

这样写是正确的；

6.aa.f();相当于C语言中的（*aa）.f();

 

31前段无声音，没有看；

 

多态

1.aa=bb;    //把bb当做aa来看待；（因为子类可以当做父类看待，所以这个语句是对的）

//aa代表的是父类的引用，bb代表的是子类的引用；

2.java里面，如果bb保存了一个对象的地址，我们就说bb代表了这个对象；

跟C语言是不一样的，C语言中，如果指针指向了i,指针不代表i，只有*指针代表i。

java中如果指针指向了i，指针就代表i。

3.多态优点：同样一个代码做不同的事情；