Java_day6

蔚落 2021-11-04 23:52 311阅读 0赞

## 第一部分:面向对象编程的四个基础特点 ##

### 封装 ###

1,属性的封装 : 将类中的数据【隐藏】  
        主要属性的访问权限进行控制  
        public 任何对象可以方法  
        protected 当前类对象和子类对象可以访问  
        private  只能在当前类中访问  
        不写 默认 当前包内可以访问

发现问题:如果属性加上了private修饰，那么这个属性在其他类中都无法访问。  
        解决: 提供方法访问

2,方法的封装 : 将类中方法的具体实现隐藏， 为了提高代码的重用

##    第二部分:方法的重载 ##

1,定义: 【方法名相同】，【方法的参数列表不同】不讨论返回值 , 的多个方法 这些方法被称为方法的重载   
              参数列表不同包括个数和数据类型的排列都不一样。

public void show(int a)\{\}  
         public voud show(short b)\{\}  
         public void show(long c)\{\}  
         public void show(double d)\{\}  
      
    问题一: 方法1 和 方法2 是否是重载?否      
    问题二: 方法1 和 方法3 是否是重载?是  
    问题三: 方法1 和 方法4 是否是重载?是  
    问题三: 方法3 和 方法4 是否是重载?是  
    问题三: 方法5 和 方法6 是否是重载?是  
    问题三: 方法7 和 方法8 是否是重载?否  
/\*\*  
 \* 重载<br>  
 \* \*/  
public class Overload \{  
    // 方法 1   
    public void show()\{\}  
    // 方法 2   
    public int show()\{return 10;\}  
    // 方法 3  
    public void show(int age)\{\}      
    // 方法 4  
    public int show(String name)\{return 10;\}      
    // 方法  5  
    public void show(int age,String name)\{\}show(1,"");                  
    // 方法 6   
    public void show(String name ,int age)\{\}      
    // 方法 7  
    public void show(int age,int num)\{\}                  
    // 方法 8  
    public void show(int num,int age)\{\}  
\}

2,好处: 给用户对功能的调用和使用提供了很大的灵活性

注 : 重载可以是和父类中的方法进行  
      
    知识点速记:方法名相同和参数列表不同的方法就是方法的重载.

## 第三部分:构造方法 ##

1,定义：在类中方法名和类名一致，没有返回值的方法就是构造方法.  
    2,作用:   
        2.1:给属性初始化值  
        2.2:配合new关键字创建对象  
    3,小问题:  
        3.1:类中不写构造方法时，会有默认的构造方法 ,无参构造方法              
        3.2:类中手动编写构造方法以后，类中不会有默认的构造方法            
        3.3:在构造方法中可以通过this(参数)/super(参数)调用其他的构造方法 ， 其他的构造方法必须在第一行  
        3.4:构造方法可以重载

## 第四部分:对象的创建和初始化 ##

1,对象的创建 : 以类为模板创建个体  
    语法: 类名 变量名 = new 构造器;  
    内存中过程:  
        1.为对象分配内存空间，将对象的实例变量自动初始化默认值；  
        2.如实例变量显示初始化，将初始化值赋给实例变量(把默认值覆盖掉)；  
        3.调用构造方法；  
        4.返回对象的地址值；  
    class Student\{  
       private int id = 30;  
    \}  
    id  =  0;  
    id  =  10;  
class A\{

public String name = show();  
    public String show()\{  
        System.out.println("执行c");  
        return "Hello";  
    \}  
    public int id = say();  
    public int say()\{  
        System.out.println("执行b");  
        return 100;  
    \}  
    publi A()\{  
        System.out.println("执行a");  
    \}  
\}

2,对象的初始化:  
    使用有参数构造器给对象进行初始化  
    类名 变量名  = new 类名(参数列表);  
      class Student\{  
        private int id;  
    private String name;  
    public Student(int id,String name)\{  
      this.id = id;  
      this.name = name;  
    \}  
      \}  
     main()\{  
         new Student(1,"tom");  
     \}

##    第五部分: 面向对象编程的四个基础特点 ##

### 继承 ###

1,**一个类想具备某些特殊功能，可以继承具有特殊功能的父类，从而达到效果。**  
    2,**语法**:  
        public class Zi extends Fu\{\}  
    3,**特点**:java中是单继承。  
           如果不写extends某一个父类，  
           那么所有类都默认继承Object

**4,父类中什么会被继承:**  
    1,父子类同包，子类继承父类中public、protected和默认访问级别的成员变量和成员方法；继承不了父类中的私有方法和属性  
    2,父子类不同包，子类继承父类中public、protected的成员变量和成员方法；  
    3,构造器不能被继承  
    4,方法和实例变量可以被继承  
    5,子类构造器隐式地调用父类的默认无参构造器;  
    （创建子类对象时，会先创建父类对象，在子类的构造器中第一句默认就是调用父类的默认构造器）

ch7下的test1：  
        public class Z extends F\{  
          public Z()\{  
          \}  
        \}  
        public class F\{     
        \}  
  
    6,如果父类中没有定义无参构造器，只定义了有参构造器，那么子类构造器则必须显式地调用父类的有参构造器(通过super(…))，且必须放置在第一条语句，否则会有语法错误。  
    7,this()和super()在构造器中都必须为第一条语句，两者不能同时出现。  
    8,当一个子类继承了一个父类后，父类中所有的字段和方法都被子类继承拥有（包括私有的属性和方法），除了私有的属性和方法之外，子类可以任意的支配使用，每个子类对象中都拥有了父类中的所有字段。当构造一个子类的实例对象时，该对象的实例变量包括了子类本身以及父类中的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。  
    9,子类构造器用来初始化子类中所有的实例变量，而父类构造器super(实参)用来初始化父类中所有的实例变量。所以在堆中为子类实例对象分配的内存区域中包括了子类和父类中所有初始化后的实例变量  
      
**5,继承现象大总结： **  
        1. 子类重写父类方法，调用子类方法；  
        2. 子类属性与父类同名(不管子类属性前修饰符如何均允许)，如获取属性，看获取属性方法位置，如在父类中，获取的是父类属性，如在子类中，获取的是子类属性；  
        3. 子类私有方法与父类私有方法同名，如调用该方法，看私有方法被调用的位置，如在父类中，调用的是父类方法，如在子类中，调用的是子类方法；  
        4. 子类静态方法与父类静态方法同名，子类静态方法屏蔽父类静态方法。如调用该静态方法，看实例化对象时所声明的类型，如声明为父类，调用的是父类中静态方法，反之是子类中静态方法。