复习(java)：语法：面向对象

1. 类和对象

封装，继承，多态

public class Person{
//定义两个成员变量
public Sting name;
public int age;

public void say(String content){
System.out.println(comtent);
}
}

Person p=new Person();
p.name="李刚"；
p.say=29;

2.对象、指针和引用

p是引用变量，放入栈内存，指向堆内存，堆内存存放实际的对象

this指针

this指针指向调用该方法的对象：

（1）构造器中引用该构造器初始化对象；

（2）在方法中引用该对象的方法：用类中的一个方法可以访问类中的另一个方法和变量

static不可以使用this

3. 方法的参数传递机制

交换swap(a,b)的值

import java.util.*;
public class Solution{
public static void swap(int a, int b){
int tmp=a;
a=b;
b=tmp;
System.out.println("swap 方法里的，a= "+a+'\n'+"swap 方法里的，b= "+b);
}
public static void main(String[] args){
int a=6;
int b=9;
System.out.println("初始化，a= "+a+'\n'+"初始化，b= "+b);
swap(6,9);
System.out.println("交换后，a= "+a+'\n'+"交换后，b= "+b);
}
}

//-----
/*
初始化，a= 6
初始化，b= 9
swap 方法里的，a= 9
swap 方法里的，b= 6
交换后，a= 6
交换后，b= 9
*/

程序开辟：main栈区和swap栈区

引用类型的交换

/*import java.util.*;

class Solution{
public  static void main(String[] args)
}*/

import java.util.*;

class DataWrap{
int a;
int b;
}

public class Solution{

public static void swap(DataWrap dw){
int tmp=dw.a;
dw.a=dw.b;
dw.b=tmp;
System.out.println("swap 方法里的，a= "+dw.a+'\n'+"swap 方法里的，b= "+dw.b);
}
public static void main(String[] args){

DataWrap dw = new DataWrap();
dw.a=6;
dw.b=9;
System.out.println("初始化，a= "+dw.a+'\n'+"初始化，b= "+dw.b);
swap(dw);

System.out.println("交换后，a= "+dw.a+'\n'+"交换后，b= "+dw.b);

}
}
/*
初始化，a= 6
初始化，b= 9
swap 方法里的，a= 9
swap 方法里的，b= 6
交换后，a= 9
交换后，b= 6
*/

传参是对象 DataWrap

传递的是引用的地址值

所以堆内存的值保存了

4. 形参的个数

import java.util.*;

public class Solution{

public static void test(int a, String ... books){
//books看作是数组
for(String tmp:books)
System.out.println(tmp);
}
public static void main(String[] args){

test(5,"a","b");
}
}

//数组的形式

public class Solution{

public static void test(int a, String[] books){
//books看作是数组
for(String tmp:books)
System.out.println(tmp);
}
public static void main(String[] args){

test(5,new String[]{"a","b"});
}
}

5. 方法的重载

一个类定义多个同名方法

参数不同，通过参数来区分

//可变参数的重载
public void test(String msg)

public void test(String ... books)

//传参

ob.test() ; //调用 test(String ... books)
ob.test("a","b") ; //调用 test(String ... books)
ob.test("a") ; //调用 test(String msg)
ob.test(new String[]{"a"}) ; //调用 test(String msg)

6. 成员变量和局部变量

成员变量：实例变量+类变量(static 修饰)

局部变量

成员变量的初始化和内存中的运行机制

public string name;
public static int eyeNum;

//创建第一个Person对象
Person p1 = new Person();
//创建第二个Person对象
Person p2 = new Person();

//分别为两个对象的name实例赋值
p1.name="张三";
p2.name="李四";

//eyeNum
p1.eyeNum=2;
p2.eyeNum=3;

Person p1 = new Person();

第一次使用Person类，加载Person类，初始化Person类：分配内存空间，指定默认初始值；

为Person创建第一个类对象

(static)变量eyeNums初始化为0

7. 封装

@@@	private	default	protected	public
同一个类	yes	yes	yes	yes
同一个包		yes	yes	yes
同一个包或者不同包的子类中			yes	yes
全部范围				yes

* 原则

1. 类的成员变量一般用private，只有static的会考虑使用public；辅助类内部其他方法的方法，使用private

2. 某类注意做其他类的父类，希望被子类重写，而不是调用，用protected

3. 希望暴露给其他类调用的用public

8. 包

9. 构造器

初始化类，系统将类的变量设置为0或者false，引用类型的实例设置为null

构造器的重载

public class Test{
public String name;
public int count;

public Test() {}
public Test(String name,int count) {
this.name=name;
this.count=count;
}
public Test(String name,int count，double weight) {
this(name, color);
this.weight = weight;
}
}

10. 类的继承

简单的继承

每个类最多继承一个父类

所有java类继承于

public class Friut{
public double weight;
public void info(){
println{...}
}
}

pub;ic class apple extends Friut{
public static void main(String[] args){
Apple a= new Apple();
a.weight=56;
a.info();
}
}

重写父类的方法

public class bird{
pblic void fly()
{
println(){"我是fly"}
}
}

public class Ostrich extends Bird{
public fly()
{pintln(){我是Ostrich}}

public static void main(String[] args ){
Ostrich OS=NEW Ostrich();
OS.fly();  //执行Ostrich对象的fly方法
}
}

子类覆盖了父类的方法后，子类对象无法访问父类

super

需要在子类中调用父类被覆盖的方法，super

class BaseClass{
public int a=5;
}

public class SubClass extends BaseClass{
public int a=7;
public void accessOwner(){
System.out.println(a);
}
public void accessBase(){
System.out.println(super.a); //访问父类的实例
}

public static void main(String[] args){
SubClass sc=new SubClass();
sc.accessOwner(); // 输出7
sc.accessBase(); //输出5
}
}

BaseClass和Subclass都定义了变量a

SubClass的a实例变化会隐藏BaseClass的a的实例变量

创建SubClass对象，为SubClass对象分配两块内存，一块存储Subclass的a，一个存储BaseClass的a

查找方法：

查找该方法中是否含有名字为a的局部变量

查找当前类中是否包含名字为a的成员变量

查找a的直接父类是否包含a的成员变量，依次上溯，直到Object类

向上转换程序

class p{
public String tag = "我是父类"；
}

class Derived extends p{
private String tag = "我是子类";
}

public class HideTest{
public static void main(String[] args){
Derived d = new Derived();
//不可以访问Derived的私有变量

System.out.println(d.tag); //error

//向上转换
System.out.println(((p)d).tag);
}
}

11. 调用父类的构造器

构造器中调用另一个重载的构造器，使用this

子类构造器中调用父类构造器，使用super来完成

class base{
public double size;
public String name;
public Base (double size,String name){
this.size=size;
this.name=name;
}
}

public class sub extends base{
public String color;
public Sub(double size,String name, String color){
//super调用父类的构造器
super(size,name);
this.color=color;
}

}

构造器的继承顺序

java.land.Object<-----类A（继承）<------类 B(继承)

调用的顺序：先执行Object，然后执行类A，然后执行类B

11. 多态

java引用变量的两个类型：编译时类型；运行时类型；

编译时类型：声明变量时使用的类型决定

运行时类型：实际赋给该变量的对象决定

不一致，则产生多态

class b{
public int book = 6;
public void base(){
System.out.println("父类的方法");
}
public void test(){
System.out.println("父类的被覆盖的方法");
}

}

public class sub extends b{
public String book = "轻量级的java";
public void test(){
System.out.println("子类覆盖父类的方法");

}

public void sub(){
System.out.println("子类的普通方法");
}

public static void main(String[] args){
b bc = new b(); //编译类型和运行类型一样，无多态
sub sc=new sub(); //编译类型和运行类型一样，无多态
b ploybc=new sub(); //多态
ploybc.base();  //父类调用子类的方法

}
}

12. 引用类型的强制类型转换

基本类型的强制转换，只可以在数值类型之间，数值类型包括整数型，字符型和浮点型

引用类型的转换在继承的两个类之间

(type)变量

13. instanceof 运算符

判断前面的对象是否是后面的类，或者子类，实例；

=>

instanceof和(type)的联合使用

15. 继承和组合

类复用的方法：继承和组和

继承使用的原则

尽量隐藏父类的内部数据。设为private

不要让子类随意访问，修改父类

父类构造器中不要调用子类重写的方法

利用组合实现复用

继承的方式

class Animal{
private void beat(){
System.out.println("心脏跳动...");
}
public void breath(){
beat();
System.out.println("吸气，吐气，呼吸...")
}

}

//继承Animal, 直接使用父类的breath方法

class Bird extends Animal{
public void fly(){
System.out.println("我在天空自由的飞翔");
}

}

//继承Animal,直接使用父类的breath方法

class wolf extends Animal{
public  void run(){
System.out.println("我在陆地上奔跑")；
}
}

public class InheriTest{
public static void main(String[] args){
Bird b = new Bird();
b.breath();
b.fly();
wolf w = new wolf();
w.breath();
w.run();
}
}

组合的方法

class Animal{
private void beat(){
System.out.println("心脏跳动...");
}
public void breath(){
beat();
System.out.println("吸气，吐气，呼吸...")
}

}

class Bird{
private Animal a;
public  Bird(Animal a){
this.a=a;
}
public void breath(){
a.breath();
}
public void fly(){
System.out.println("我在天空自在的飞翔...");
}
}

class wolf{
private Animal a;
public wolf(Animal  a){
this.a = a;
}

public void breath(){
a.breath();
}
public void run(){
System.out.println("我在陆地上奔跑")；
}
}

public class CompositeTest{
public static void  main(String[] args){
Animal al = new Animal();
Bird b = new Bird(al);
b.breath();
b.fly();

Animal a2 = new Animal();
wolf w=new wolf(a2);
w.breath();
w.run();

}
}

16. 初始化块

初始化块在构造器之前