黑马程序员_Java面向对象1

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

：定义一个手机类：
       成员变量：String brand,int price
       构造方法：无参，带两个参数的构造
       成员方法：getXxx()/setXxx()
        call(String name)
                show()方法，用于显示手机的品牌和价格。

  然后定义一个测试类，测试上面的代码。
A:无参+setXxx()赋值。
show()
call(String name)
B:有参赋值。
show()
call(String name)

现在提到的关键字是：private this String static extends （super 和this） final abstract 
   Interface(接口的关键的第一个开头的字母必须是大写的I，否则是错误的) 
   implements instanceof 

留意：当学了private以后，变量定义的时候就要带上private。如：private int age=3；

      当学了构造函数以后，那就是说，以后再写类的时候就要手动写上构造函数！

      比如说：

      class student{

    public student{}
}

构造函数的条件：1.构造函数的函数名和类名一致
             2.函数没有返回值类型
         3.函数没有返回值，就连void都没有。

留意： 如果配调用的类中没有构造函数，那体统会自动给一个无参的构造的函数，这个构造函数没有输出。

  例如：class Student{}
如果我们自己给出了构造方法，那系统就不自动给构造方法了。
自己给出的构造方法，包括了，1.有参的构造方法，2.没有参数的构造方法。

      （一般在写程序的时候出于习惯也要给出一个无参构造方法）
其中可以给出好几个有参数的构造方法。这个就叫做构造方法的重载。
而无参的构造方法却只能有一个！！！
如果自己给出了有参的构造方法，自己又没有出于习惯写出无参构造方法。
但还是想用无参的函数构造方法，你就必须自己手动给出了。

有返回值的函数，函数名和方法名一致，那就只能是普通函数，不是构造函数。只能通过对象调用。

如果是用要实现一种功能，最好一个函数只实现一种功能，不然后来就很难以维护，

也就是说函数写的时候尽量“别太具体”；

在第八天又有一个关键字：static
static是静态的意思，用来修饰成员方法，和修饰成员方法。主要是节省空间。
A:随着类的加载而加载。
B:优先于对象存在。这个static是不能使用this关键字，因为this是随着对象的存在而存在的。而
 static是随着class加载而加载的，而且是优先于对象存在的。所以说static是不允许
         this使用的。
C:静态的类名是可以通过调用的。eg： publid static void Xxx(){}就是这种形式的方法，可以通过对象
调用的。

          对象可以调用 ：有参数的构造函数。我不知道可不可以调用无参数的构造方法。静态的方法，非静态的方法。
D:静态的方法可以通过类名调用，同样可以通过（类名.方法名）这种方法调用。
（类名.方法名）只能可以调用静态的方法，不可以调用非静态的方法。（重点）
非静态的内容只能用对象名调用。
静态的内容既可以通过对象名调用，也可以通过类名调用。推荐用类名调用，不用对象调用。

  E：静态是被所有对象共享的
其实这句就是告诉我们，如果这个方法是要共享的，那就要将这个方法定义为静态的。

        留意：如果学了对象，建议还是不要随便共享方法吧。因为测试。

非静态方法可以访问静态变量，也可以访问非静态变量。

静态方法只可以访问静态方法，不可以访问非静态变量。

非静态方法可以访问非静态方法，也可以访问静态方法。

静态方法只可以访问静态方法。不可以访问非静态方法。

this的作用还有一个就是，能够从一个方法引入另一个方法。

    代码块：就是用{}括起来的代码。

     局部代码块：就是为了限制变量的生命周期，提高效率。

     构造代码块：把多个构造代码块中相同的代码提取出来。在调用构造方法的时候，会自动调用构造代码块。

                  在构造方法之前就将代码块写上，那在调用构造方法的时候自动调用代码块。

                  如果是在前面加上关键字static，那代码块只执行一遍。

     静态代码块：也就是静态代码块只执行一遍，而非静态代码块执行两便。
或者说静态代码块依次执行，而构造代码块在调用的时候才执行。

注释/*...*/不可以嵌套.也就是说：如果/*碰到*/会将中间的代码自动注释掉，不会自主的随着程序员的想法

选择下一个*/

例如：/*  xxxxxxxxxxxxxxxxxxx */ */  

也就是说第一个(/*)碰到第一个( /*)   会自动将中间的注释掉，不会选择*/

如果方法中没有使用类的非静态成员，那么这个方法就可以考虑用静态方法。

当我们自己的类已经运行成功了，为了不让外界造对象，来实例化，我们尽量让自己的方法加上私有化。

例如：

/**

*author yulongchao

*version v1.0

*只是对数组操作的数据类

*/

//这是一个工具类；

class ArrayTool{
private ArrayTool(){
System.out.println("我的地盘听我的");
}
public static void printArray(int arr[]){
//public static void main(String[] args){
for(int x=0;x<arr.length;x++)
if (x<arr.length-1){
System.out.println(arr[x]);
}
else{
System.out.println(arr[x]+",");
}
}
}

// 这是两个类，只不过在一个包下，不是想以前的那种将两个文件，统统放到一个java文件里。

class ArrayDemo {
public static void main(String[] args){
int[] arr={1,2,3,4,5};
ArrayTool at=new ArrayTool();
ArrayTool bt=new ArrayTool();
at.printArray(arr);
//ArrayTool.printArray(arr);
}
}

其实，最正规的是：一个类一个java文件的。

作为面对对象的java语言，就是这样，不像是面对过程的，一个接一个的函数，而面对对象的变成文件，

都是一个类一个java文件，这样后期是容易维护的。因此一个类一个java文件，以便别人来用这个类，

但是不会给予别人java文件的，而是class文件，这样文档就产生了。为了保证知识产权。

所以自己写好的java文件，给别人都是class文件同时配套一个说明书（也就是帮助文档） 

javadoc -d  -author -version xxxx.java这个如何使用doc生成一个API文档。

如何使用API文档

1：首先打开API，双击打开即可。

2：明确你使用的是那个类？举例：Mate

3：打开以后单机显示，单机索引。

4：在索引下面输入Math。

    其中类的结构：

  成员变量：字段
构造方法：构造方法
成员方法：方法。

看包结构
java.lang类Math

        记住：（如果类在java.lang包的下面，那么在使用的时候是不需要导入包的。）
     而在其它包下面的类，在使用的时候是需要必须导入包的。（例如：以前的Scanner）

  导入包的过程
import  包名... 类名；

5：看类的基本描述信息。了解类是干什么的？

6：看“一下版本开始”

7：看构造方法。
要不有构造方法；通过构造方法创建对象，然后通过对象去调用类中的方法。
要不没有构造方法：通过所有的成员都是静态的。通过对静态方法的方法返回本类的对象。

         （重要的是：如果构造方法别私有后，api是看不到构造方法的）

8：看成员方法
左边：
看是否静态：如果是静态，可以通过类名调用。
返回值类型：返回什么，就用什么接收
右边：
方法名：名字不可写错。
参数：人家要什么，你就给什么。

继承的好处：一：提高了代码的复用性。
   二：让类与类产生了关系，这是多态的前提。

java中继承的特点：

A:java只支持单继承（简单的说就是一个父亲只有一个孩子）

     假设java可以继承多个类，格式，就是在extends写多个类，类之间用，隔开。

B:java中可以多层继承。（也就是多从继承）。

在java中不要为了实现父类中的某一功能，而去继承，这样的话，其它的方法也会相应的被继承了。

例如：

class father{
public void show(){
System.out.println("show");
}
public void method(){
System.out.println("method");
}
}
class son extends father{

}
class extendDemo{
son a=new son();
son.method();
}

像这种例子，就是说，son类为了实现method（）方法，结果对father类进行了继承，因此show（）方法也

相应的得到了继承，所以不是“is a”的原因，单单为了实现father方法的某一个方法，就没必要去继承。

到底什么时候用继承：

比如说  类是动物。猫类就继承了动物。“is a”猫是动物中的一种。

如果这个时候给出了两个类，A和B。如果说：A是B中的一类。那么A和B是一种继承关系。

继承间的成员变量之间的关系：

A：成员变量名称不同     （例如）该用谁就用谁。

class father {
int num=1;
}
class son extends father{
public void show(){
System.out.println(num);
}
}
class extends2 {
public static void main(String[] args){
son a=new son();
a.show();

}
}

B: 成员变量名称相同    

这个时候的调用顺序，在局部范围找是否有，有就使用，然后在成员变量范围找，如果成员变量

中没有，那就在父类的成员变量中找，不可能在父类的局部变量中找。就是就近原则。

class father {
int num=1;
}
class son extends father{
int  num=2;
public void show(){
System.out.println(num);
}
}
class extends2 {
public static void main(String[] args){
son a=new son();
a.show();
}
}

关于函数的继承，关于变量的名字一样，那就就近原则。但是如果是有三个相同名字子类的局部变量直接调用，

成员变量那就用this调用，super用来调用父类的成员变量，关于局部变量，不管任何时候，永远不可能调用。

super表示的是父类的存储空间，可以理解为父类的一个引用对象。

this表示的是本类的引用对象。

在继承关系中，如果父类中定义了一个变量，并且这个变量没有初始化，那子类就不能调用父类的这个变量。

class father{
int num;
//int num=2
String num;
public father(){
System.out.println("father()");
}
}
class son extends father{
public son(){
System.out.println("son()");
System.out.println(num);
System.out.println(num2)
}
}
class jicheng6{
public static void main(String[] args){
son s=new son();

}
}

例如这段代码，其中num的值如果已经初始化了，那在子类中的构造方法中就输出初始化的值， 例如int num=2;
假设num值没有初始化，那就输出0；同样，num2一样。

子类中所有的构造函数默认都会访问父类中空参数的构造函数。子类中的所有的构造函数，这个构造函数包括了

带参数的构造函数和不带参数的构造函数。而父类中空参数的构造函数，指的就是构造函数没有参数。

每一个子类中的构造方法都会默认的访问父类中的  无参构造方法  因为构造方法的每一条语句的第一行都有

一条默认的语句  super();

有些人会觉得我没有写子类构造方法为什么还会有这种情况呢？

因为：每个类中，如果没有手动给出这个类的构造方法，那系统会自动给出一个无参构造方法。

      子类中没有手动给出构造方法，系统会自动给出一个无参构造方法，接着默认访问父类的

      无参构造方法。

所以只要父类中有构造方法，负责调用的是默认调用的。其实隐含了一条语句：super();最好写上。

这个时候并没有创建父类的对象，只是对父类的数据进行了初始化。

子类的构造函数不管是  有参数的  或者是  无参数的  

只要创建了对象，就无条件调用子类的构造方法，当然创建对象的时候看看给不给参数。

如果给了那就调用了有参数的

没有给那就是调用了无参的。

但是，访问父类的  无参构造  是没有条件的  只要调用了子类的构造方法，不管是有参无参的子类的构造方法，

都直接调用了父类的无参构造方法。

每一个子类的构造方法不管是  有参数的  或者是没有参数的。

第一条语句都有一个默认的语句就是：super（）；

也就是说都是默认调用父类的无参构造。

输出的时候先是输出父类的构造函数语句，然后是子类的构造函数语句；

那为什么不是默认调用父类的带参构造方法呢？因为要传值。

所以假设你要调用父类带参的构造方法？

那就需要用 super(参数);

eg：class father{
public father(){
System.out.println("father()");
}
}
class son extends father{
public son(){
System.out.println("son()");
}
public son(String name){
System.out.println(name);
}
}
class jicheng9{
public static void main(String[] args){

son s2=new son("yulongchao");
}
}

这段代码是先输出  father()
 yulongchao

如果是：  yulongchao
 father()   

那就是错误的。必须先执行父类后执行子类。

总之一句话，1.想要调用带参数的父类构造方法必须要  super(参数);
      第二种方法就是this（）；

          （但是特别值得注意的是：this（参数）和super（参数）只能有一条出现在子类的构造方法中
  的第一条语句中。只能有一条。）
 （值得注意的有两点：
   第一点：对super（）的调用只能是出现在构造函数的第一句

            第二点：对父类中构造函数的调用的两个方法super（参数）和this（）必须只能是一条。）

            2.//想要调用不带参数的父类构造方法只需要 super();

                这个地方你不带super（）系统也会自动生成帮你调用
     //还有一种方法就是this（），这个方法不常用。
具体体现和理解看下列代码，或者翻看视频第九天的视频（继承间的构造方法的关系）

class father{
public father(String name){
System.out.println(name);
}
}
class son extends father{
public son(int sex,int sey){
super("haha");
System.out.println("sex的值是："+sex+"sey的值是："+sey);
}
public son( ){
this(6,7);
System.out.println("HelloWorld");
}
}
class jicheng2{
public static void main(String[] args){
son s=new son();
}
}

继承中构造方法间的关系：
特点：初始化子类之前，先初始化父类的数据。
注意事项：
A:调用父类的构造方法，是默认调用的。其实隐含了一条语句：super();
 这个时候并没有创建父类对象。仅仅是对父亲的数据进行了初始化。
B:每个构造方法中，第一条语句默认是super();表示调用的是父类的无参构造方法。
假设你要调用父类的带参构造方法，该怎么办呢?
super(参数...);
C:当父类中没有无参构造方法该怎么办?
a:用super调用父类的带参数构造方法。
b:用this调用本类的其他构造方法。(比较少)
 本类中肯定要有一个调用父类的带参构造方法。
D:构造方法中this(...)或者super(...)只能出现一个。
 并且，还都必须在第一条语句上。
 避免多次对父类的数据进行初始化。

一个类的初始化过程：

先是走成员变量默认初始化，再是成员变量先是初始化，最后是变量构造初始化

具有子父类关系的类的初始化：

先初始化父亲的数据，然后初始化子类的数据。

当出现继承关系的子父类的关系的时候，在测试类中的super（），并不是指调用父类的有参构造

而是决定了，初始化先后。

构造代码块，在调用构造方法之前才执行，而且只有调用构造才能触发去执行构造代码块。

而静态代码块是自动执行。静态是随着，类的存在而存在，也就是说：有时候执行静态代码块的

时候，并没有创建对象。它仅仅是加载代码。

/*
1：类本身的初始化过程
2：具有子父关系的类的初始化
3：静态是随着类的加载而加载
结论：
Fu 静态代码块
Zi 静态代码块
Fu 构造代码块
Fu 构造方法
Zi 构造代码块
Zi 构造方法

这道题：在执行的时候先是执行父类的静态代码块，然后执行子类的代码块。
把刚才的那道题目和这道题给揉和到一起。(留作思考)

*/

class Fu {
static {
System.out.println("Fu 静态代码块");
}
{
System.out.println("Fu 构造代码块");
}
public Fu() {
System.out.println("Fu 构造方法");
}
}
class Zi extends Fu {
static {
System.out.println("Zi 静态代码块");
}
{
System.out.println("Zi 构造代码块");
}
public Zi() {
System.out.println("Zi 构造方法");
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
}
}

在子类中调用父类的有参数构造方法，关于super（参数），和this（参数）

注意两点：一：只能有一种形式。二：必须某一种形式在子类构造方法的第一条语句中。

继承中的成员方法的关系：

A: 不同方法声明的方法
该调用谁就调用谁。

B：相同方法声明的方法
也就是典型的方法复写，方法重写，方法覆盖。
如果是父类和子类中都有相同的一个方法，而且参数也一样，那就调用的时候只能调用子类的
方法。

方法重写的格式要求：

子类中出现了和父类中一模一样的方法声明。

方法体可能跟父类的一样，但是也有可能不一样。不能说是肯定不一样。

方法重写的注意事项。

1.中私有的东西子类是不能访问的。

2.子类只能访问父类中的非私有的成员。

3.当子类中的化为私有的时候，测试类也不可以访问。（视频中这个地方引入了super（）的引用，第一就是当变量同名的时候，引用父类的成员变量。第二就是当引用父类的有参构造的时候，第三就是引用父类的非成员变量的时候。）

4.如果存在私有的方法，是不存在重写这种说法的。

5.void 类名{}这个时候没有给修饰符，此时的修饰符就是默认的修饰符，不是public也不似private。

6.子类中的方法的访问权限要大于等于父类的方法访问权限。

父类中：void 小明 {}

子类中：void 小明 {}  

像这种情况会选择子类。void 类名{}这个时候没有给修饰符，此时的修饰符就是默认的修饰符，不是public也不似private

父类中：public 小明{}

子类中：void   小明{}

像这种情况会报错。就是说：如果父类的是public，子类中想要重写，也必须是public，

所以正确的方式：

父类中：public 小明{}

子类中：public 小明{}

父类中：void  小明  {}

子类中：public小明  {}

这种情况也不会报错。

重写的时候注意事项：

1、私有方法不能被重写。

2.子类中的方法的访问权限要大于等于父类的方法访问权限。一般来说，建议跟父类中的方法声明一模一样。

3.静态方法只能是被静态方法重写（但是这个地方得提一下，static毕竟是跟类有关的，所以并不算是重写）。

重载和重写的却别：

重载可以改变返回值类型，因为他跟返回值类型无关。

重写（override）

重载（overload）

this和super的区别

this代表当前类的引用对象。

super代表父类的存储空间标识。可以理解为父类的一个引用。

this和super的区别,以及应用场景?
this:代表当前类的引用对象。
super:代表父类的存储空间标识。可以理解为父类的一个引用对象。
应用场景：
A:调用成员变量
this.变量 调用本类的成员变量
super.变量 调用父类的成员变量
B:调用构造方法
this(...): 调用本类的构造方法(很少用，面试可能看到)
super(...): 调用父类的构造方法(可能会用到)
常见：父类中的成员变量私有，子类要通过构造方法给其赋值。
C:调用成员方法
this.方法名(): 调用本来的其他方法
super.方法名(): 调用父类的方法

class Fu {
public void method() {...}
}
class Zi {
public void show() {
//this.method();
//super.method();
System.out.println("show");
}
public void method() {...}
}

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------