Java基础/新手入门之面向对象OPP(Part02)

变量分类(按照位置变量分)

**成员变量:**成员变量是定义在类中,方法体之外的变量.成员变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型).在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化. 成员变量在创建对象的时候会从类中复制一份到对象中.成员变量可以被类中方法、构造方法和特定类的语句块访问.成员变量的作用范围为整个类体.
**局部变量:**在方法,构造方法或者语句块中定义的变量被称为局部变量. 局部变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型).局部变量在使用前必须初始化赋值.变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁.

成员方法:成员方法是定义在类中.这种方法在创建对象的时候创建.
语法格式：
修饰符 返回值类型 方法名 ( 参数列表) {
方法体语句；
[return 返回值]
}

public void guess(){
    java语言
     return;
}

构造方法:用来创建对象的方法,构造方法名与类名相同,且没有返回值,且不需要使用void修饰.

一个类可以有多个构造方法.

普通的构造方法

public Car(){ } 

含参的构造方法

public Car(String name){ // 这个构造方法有一个参数：name } 

方法的重载

方法的重载是指同一个类中具有相同的名字,但参数不同的多个方法.
参数不同的三个方面:数量不同,类型不同,顺序不同.
调用时,会根据不同的参数表选择对应的方法.
注意:方法重载跟方法的返回值类型没有任何关系.

static 关键字

static被称为静态的,用来修饰类的属性,方法,代码块,内部类.

类变量只有一份,static修饰的变量也只有一份.

static String country = "中国";

成员方法中可以访问成员变量,还可以访问静态变量

public void testMethod() { System.out.println(country);}

静态方法中不能访问非static属性,只能访问类的static属性.

静态方法先于对象存在,static属性先加载.

public static void testStatic(){    
    /*System.out.println(name); 编译错误！！！*/
   System.out.println(country);
}

static方法可以用类名直接调用,也可以使用对象调用,建议用类名直接调用

static修饰的成员，被所有对象所共享

public class Chinese {    
    String name;    
    int age;    
    String address;
    static String country = "中国";
}

public class TestChinese {
    public static void main(String[] args) {
        Chinese ls  = new Chinese();
        ls.name = "阿星";
        ls.age = 20;
        ls.address = "西安市";
        System.out.println(ls.name+"|||"+country+"|||"+ls.age);
    }
}

代码块

代码块在类中声明，类似一个没有名称的方法体(代码块),代码分为实例块和静态块.

实例块:每次创建对象时自动调用

**静态块:**类加载时自动调用,仅一次,与是否创建对象无关.

public class damaikuai {    
    static  int PI = 1234;      
    {              
        System.out.println("实例块1");        
        System.out.println("实例块2");    
    }    
    static{        
        System.out.println("静态块1"); //先加载       
        System.out.println("静态块2");   
    }   
    public static void main(String[] args) {        
        new damaikuai();        
        new damaikuai();        
        System.out.println(damaikuai.PI);    
    }
}

运行结果:

静态块1
静态块2
实例块1
实例块2
实例块1
实例块2
1234

/*

      静态块1
      静态块2
      实例块1
      实例块2
      实例块1
      实例块2
      1234
*/

包

包(package);类似于文件夹.

作用:1)避免类重名;2)按照不同的功能管理类;3)控制访问权限.

在java程序的第一行加入"package 项目的类型+开发或者运行的公司名+项目的名称+模块的名称",就可以把*.class文件保存在相应的包内:当需要调用此包中的类时,用"包名称.类名称"的格式调用,这样可以避免相同类名的冲突.

包的导入:import+全类名(包名.类名)

内部包不需要用import关键字导入,java.lang包中的类在使用时不需要导入.

访问权限修饰符

Java语言有四个权限访问修饰符，权限从大到小依次为：
1）public ：公共权限 修饰类、属性、方法。可以被任意类访问.
2）protected：受保护的权限 修饰属性、方法.
可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问.
3）default：同包权限 修饰类、属性、方法。只能被同包的类访问.
4）private：私有权限 修饰属性、方法。 只能在本类中访问.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b9yqQ00R-1608184629791)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\1607395199275.png)]

代码实例:

public class Demo {
	public int publicc;
	protected int protectt;
	int defaultt;
	private int privatt;
	public void publicc(){ }
	protected void protectt(){ }
	void defaultt(){ }
	private  void privatt(){}
}

封装

概念:将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来对隐藏的信息进行操作和访问.

封装的好处:1) 只能通过规定的方法来访问数据;2) 隐藏类的实例细节,方便修改和实现.

代码实例:

public class Demo {
    //属性使用private权限
    private String name;
    
    //方法使用public权限
    public String getName (){
        return name;
    }
    public void setName(String name){
        this.name = name;
        //使用"this.成员变量名"这样的格式来引用成员变量名.
        //用来区分同名的成员变量和局部变量.
    }
}

this关键字

this关键字代表自身类的对象.使用this关键字引用成员变量;使用this关键字引用成员方法.
注意：this关键字必须放在非静态方法里面.

继承

继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行为,并能扩展新的能力.

优点 :1) 创造更为特殊的类型. 2)消除重复代码. 3)便于维护

在JAVA中使用extends关键字来表示继承关系,且一个类只能有一个直接父类.

子类可以调用父类的所有非私有属性和非私有方法.

继承的形式：[访问权限修饰符] [修饰符] 子类名 extends 父类名{子类体}

public class Animal {
   //public class Animal extends Object{}
   //当一个没有继承任何一个类时,jvm会默认让类继承Object类
   //Object是 java为所有类提供的基类 
}

继承中的构造方法

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法
可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法
如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。
原因:子类创建后需要调用父类的方法,所以在创建子类对象是父类也需要同时被创建.

super关键字代表父类的引用，在程序中主要的用途

父类:

public class Animal {
    private String name;
//在idea中可以右击鼠标后+Generate+ Getter and setter + "ok!" 来调用Getter和Setter
    public String getName() {   
        return name;
    }
     public void setName(String name) {
        this.name = name;
    }
}

子类:

public class Dog extends Animal{
    private String Species;
    public Dog(String species) {
        super();//在子类的构造方法的第一行系统会默认调用,有且仅在第一行
        this.Species = species; //this关键字必须放在非静态方法里面
        System.out.println("Dog中有参的构造方法");
        super.getName();   //用“super.方法名（参数列表）”的方式访问父类的方法
                           //“super.方法名（参数列表）”的方式访问父类的方法
    }

方法的重写(OverRide)

方法重写: 当子类中的实现步骤与父类中的实现方式不同时,可以在子类中重写方法.

重写规则:

1)方法名相同、参数列表相同；

2)返回值类型相同；

3)访问权限等于或大于父类权限;

4)构造方法不能重写.

public class Animal {
    public void eat(){
        System.out.println("它喜欢吃饭");
    }
}
//子类
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("它特特特特别喜欢吃骨头");
        super.eat();//super通常表示当前类的父类对象
    }
}    

子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法

class Test{
    static{
	  System.out.println("Test静态代码块");
	}
    {
	  System.out.println("Test实例代码块");
	}
	Test(){
		System.out.println("Test无参构造方法");
	}
}
class Demo extends Test{
     static{
	  System.out.println("Demo静态代码块");
	}
    {
	  System.out.println("Demo实例代码块");
	}
	Demo(){
		System.out.println("Demo");
	}
	
	public static void main(String[] args){
		new Demo();
	}
}
/*
  运行结果:
    Test静态代码块
	Demo静态代码块
	Test实例代码块
	Test无参构造方法
	Demo实例代码块
	Demo
*/

重载与重写的区别:

重载：必须就有不同的参数列表;可以有不同的返回类型;可以有不同的访问修饰符;可以抛出不同的异常.
重写:参数列表必须与被重写的方法的相同;返回的类型必须与被重写的方法的相同;访问修饰符的限定必须大于被重写的方法的访问修饰符（public>protected>default>private）;重写方法一定不能抛出新的检查异常或者重写的方法申明更加宽泛的检查异常.