新人自我总结类与对象 继承和多态

自我总结第二篇

原因没有接触过Java的时候，常听到跟我介绍JAVA的人说一句话，Java是面向对象的编程，C是面向过程编程的语言，你只需告诉他应该怎么做就可以了，不需要具体的一步一步的去实现。这句话其实真的没什么用，因为真的一无所知，虽然我并不知道为什么他们只会说这句话。 但是学习编程就是这样，有很多的东西，你不了解的东西你不需要非得去了解透彻，随着时间的推移，随着你知识的积累，你自然而然的就懂了，比如最开始的主程序，main主函数，为什么一定要这么写，当你学到访问修饰符，学到静态，学到返回值，学到数组，你自然就明白了，不需要刻意的强调，就是这样，所以我一直强调的学习方法就是不要钻牛角，不是指你不深究，而是学会判断，懂得取舍，这样才能学得好，学得快，学的远。

3.java中一语句，包括方法的调用

3.0错误！！！

1.调用方法时，方法中使用的形参数因为常和传入的实参名字相同而导致误以为是同一个，实际两者不相同，不过如果要对实参进行改变，则应在调用的方法内部访问实参所在类的方法或者对象。即两者相互调用。注意此处说得不正确，得分引用和基本数据类型，基本不是同一个，而引用是同一个
2.常用一个东西时，可以使之静态化，包括Scanner
3.多态中，只有方法重写才有多态，而属性是不能重写的，所以没有多态

3.1构造方法

//不能在显式调用构造函数时引用实例字段，除非静态化实例**

private name;

Person(){
this(name);//显示调用其他构造器不能使用实例化的字段，可以直接使用字符串和数字。
}
Person(String name){
this.name=name;
}

class Cat{
	Cat(String name){//构造方法 
	}
 void name(String name){//普通方法
	}
}
1.构造方法与类同名且没有返回类型，主要作用为进行初始化，可在声明的时候调用Cat one =new Cat("小花")；默认有一个空的构造方法，重写构造方法后，就不能声明时调用空的那个构造方法，因为不存在了。

2.构造方法private修饰后，就无法new该类的对象，加静态方法和静态属性 即封装该类

3.==匿名对象==  new Car().color="蓝色"
1.当对象只调用一次	2.可以当做实参传递```

## 3.2构造代码块
{
System.out.println();
}
给当前类中所有的构造方法初始化，优先于所有构造方法执行，且每个new对象只执行一次。调用构造方法时才执行

## 3.3静态构造代码块
static{
System.out.println();
}
作用：用于给类初始化，只执行一次，**且优先于主函数运行**，只要类出现就执行，静态成员变量也是如此，因为类只加载一次，new对象的时候不加载类。

## 3.4构造函数之间的调用
1.用this(实参),来进行表达，且只能放在第一行。调用父类构造器则使用用super()两者只能存在一个，都要在第一行，且默认都是有super的

## 3.5对象初始化过程
1.因为new Student()用到了Student类；所以会把它从硬盘上加载进入内存
2.如果static静态代码块就会随着类的加载而执行，还有静态成员和普通方法也会随着类的加载而被加载，**方法区**
3.在**堆**中开辟空间，分配内存地址
4.在堆中建立对象特有属性，并同时对特有属性进行默认初始化
5.对属性进行显示初始化
6.执行构造代码块。对所有对象进行初始化
7.执行对应的构造函数，对对象进行初始化
8.将内存地址给S（给**栈**中的变量）

## 3.6  23种设计模式
1.**单例设计模式**，只允许某一个类只有一个对象
![在这里插入图片描述](https://img-blog.csdnimg.cn/20190410211008797.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6NjMwNTg2ODAy,size_16,color_FFFFFF,t_70)
private 修饰构造方法，即允许new 的对象，怎么办呢，可是事先new好一个对象，通过静态的方法来得到这个对象。

2.**模板设计模式**
功能的一部分时确定的，而确定的部分在使用不确定，那么这时就得不得不将不确定的部分暴露出去，由该子类继承去完成。加abstract方法由子类重写。
还有几种的设计模式，因为我还没去学，因为基础没有用到这些设计模式，所以学习比较少，如果有兴趣的可以自己搜索一下，23种设计模式

## 3.7类可以作为属性
减小内存，当方法中存在需要使用的其他类时，我们可以将该类设置为该类的属性，只声明不引用，这时的占用的空间为0；当需要用到有此类的方法时，则在主方法中声明并赋予对象，例如
boy 这个类中有一个dog的属性，Dog d;需要用到时，则在主函数里面Dog z=new Dog;
boy.d=z;属性为关联关系，方法为依赖关系

## 4 封装 继承 多态
## 4.1封装
**关键词：private**
1.封装属性
2.封装方法
3.封装类

4.2继承

关键字：extends**

1.提高复用性，简化代码，类与类之间产生了继承关系，才有了后面的多态特性
2.子类不能拥有父类中被private修饰的成员
3.多继承，最下层之类拥有整个体系的成员
4.java不支持多继承，存在安全隐患，如果多个父类定义了相同的成员，子类不确定运行哪一个。java保留了这种机制，并用另一种方式实现，多实现，即接口
5.this,super。this 访问当前对象的属性，如果没有，则去父类找。而super,访问的父类的属性。如果父类没有，则报错,子类要使用父类中的成员，只能写在方法中，进行修改。
6.子类方法覆盖父类方法，即重写，必须保证子类方法访问权限大于父类访问权限（public>default>private)。静态的方法只能覆盖静态的方法。
7.重载和重写，重载只看同名方法的参数列表,有多个方法。重写是子父类方法要一模一样，只有一个方法。
重载：父类：void cat()		子类：void cat(String name)
重写：父类：void cat()		子类：void cat()
8.子父类中的构造方法，1.父类构造方法无法重写2.子类的每一个构造方法第一行默认有super()，作用调用父类没有参数的构造方法，如果父类的构造方法是有参，则需要显示调用 否则会报错


## 4.3多态
多态，事物存在的多种形态
**1.多态的体现：父类引用指向子类对象**<u>最明显的地方就是形参写父类，却可以传子类，且调用的方法的是子类的方法，当每个子类对于父类的某种方法进行改变时，只需要将父类的这个方法放入另一个方法内，形参设为父类即可，同时子类必须重写，要不然调用的就是父类，就没有意义了，显得多余。</u>

2.多态的前提：1必须存在关系（继承或者实现），2有重写

3.多态的好处：大大提高了程序的可扩展性

4.多态的弊端：提高的程序可扩展性，只能用父类的引用，访问到父类的属性

5.多态成员变量的特点：编译期间参阅的是引用型变量所属的类中是否有调用的方法。  运行期间：参阅对象所属类中是否有调用的方法。Animal a=new Cat,Animal 是引用，Cat是所属类中

**<u>注意事项：</u>**父类的成员变量是没有重写这个说法的，只能继承，能形成多态的只有方法，没有属性。如果重写了属性，则你传的什么类型，就调用那个类型的属性。

public class Traffic {     
	public int people;    
	public String location;    
	@Override     
	public String toString() {         						
	return "Traffic [people=" + people + ", location="	 + location + "]";    
	}
}

public class Bus extends Traffic {     
	public int people = 40;                
	public String location = "陆地";   //重写属性     @Override     
	public String toString() {     		、
				return "Bus [people=" + people + ", location=" + location + "]";     
	} 
}  

public class Initial {     
public static void main(String[] args) {         
	Traffic tra1 = new Bus();        
 	System.out.println(tra1);       //输出Bus [people=40, location=陆地]                 
 	 System.out.println(tra1.people);//输出0，为什么不是40？成员变量不能重写？    
	}
}


## 4.4对象的转型
向上转型，子类默认转换为父类Animals a=new Cat();
向下转型，父类强制转换为子类Cat c=(Cat)a;
关键字：instanceof  左边测试的对象是否属于右边的实例 注意子类对象属于父类的实例，但是父类的对象就不是子类的实例了
返回值是true 或者false,必须是子父类关系才能
<u>***注意：***如果父类直接转换成子类，编译没问题，但是运行会出错，不能直接转换，因为父类的引用指向子类对象，没有指向子类对象则错误。</u>


## 4.5interface接口
1.初步理解，接口是一个特殊的抽象类，当抽象类中全部是抽象方法时，可以通过接口的形式**实现**，类似于继承，实现implements
区别于类中的继承，**可以多实现**。接口降低了类与类之家耦合性，接口可实现，可不实现。
2.格式：类：interface name{};属性：public static final String NANE="小李"；方法：public abstract void show();只能用public访问修饰符
3.接口不可以创建对象，因为子类只有将所有抽象方法实现后才能实例化。
4.默认方法都是抽象的，**默认变量都是静态常量**
5.接口之间是继承，类之间是继承，类与接口是实现

## 4.6继承中，程序的执行顺序
父类静态变量以及静态程序块---子类的静态变量以及静态程序块---（子类的构造方法中的super）---父类非静态代码块---父类初始化---父类构造方法---（返回）子类中构造方法（不执行super后的语句）---子类中非静态代码块---子类初始化---子类中构造方法(super后的语句)---对象调用的方法(子类寻找，找不到在去父类找)。

## 4.7内部类
1.静态内部类

作为类的静态成员

无需新建外部类，直接新建内部类，可直接用，可以访问外部类的静态成员

2.成员内部类

作为类的成员1.服务于本类，不被其他类所调用，一般不在外部单独新建对象	2.会调用很多本类的很多属性，节约空间与可读性	

需新建外部类和在内的内部建立内部类，才能使用，可以访问外部类所有成员，如何区分两个this之间的区别，**内部就是一个this，而外部的是==外部类名.this,**

3.局部内部类

作为方法的成员

只能在方法内部声明并使用，可以访问外部类和方法的成员，需要将成员修饰为final,同时方法加载后，该类被清除。

4.匿名内部类

类似于继承（注意JDK1.8以下不能直接使用方法的局部变量，需要将局部变量设置为全局变量）

**注意：设置界面需要经常使用到匿名内部类，匿名内部类的this是指匿名的对象，需要用到外部的对象时，应该加外部类的类名.this。**


public Person{
    public void show(Student msg){
        msg.show();
    }
}

class Student{
    public void show(){
        System.out.println("我在成员内部类中");
    }
}

public class Test{
    public static void main(String[] args){
        Person p=new person();
        p.show(new Student()){//匿名内部类的用法，student是父类，属于被继承，下面的方法是他被重写的方法
            public void show(){
                System.out.println("在匿名内部类中");
            }
        }
    }
}



一道题 请问第一次输入字母a  第二次输入数字3 请问返回值是多少

Scanner in =new Scanner(System.in);
public int get(){
    int t=0;//？ t 不能放在方法内
    try{
        t=in.nextInt();
    }catch(Exception e){
        System.out.println("输入有误，请重新输入");
            in=new Scanner(System.in);//？刷新in
        	this.get();
    }
    return t;
}