类与对象的相关知识点--上

面向对象的三大特性

1. 封装性：把客观事物封装成抽象的类，并且类把数据只给可信的类或对象操作，对不可信而进行信息隐藏。
2. 继承性
3. 多态性：多态指一个类实例的相同方法在不同情况有不同表现形式；

基本概念

对象：指一个具体的，可以使用的事物；
类：具有相同属性的对象的集合，指共性的概念；
类的组成：（1）方法（2）属性
注：Java中出现new，表示开辟内存了（堆）
Java中的内存大概分为：堆内存与栈内存

堆内存：保存的是实际存储的数据【对象的属性信息】
栈内存：保存的是局部变量【包含 基本数据类型、对象引用（对象的名称）】

注：引用数据类型必须在实例化后调用，否则会产生NullPointeron（运行时错误）；
引用类型有：数组、类、接口

• 封装：
  (1) 用private对属性进行封装时，若要访问则需提供两种方法：getter(获取）、setter（对数据进行修改与设置）
  (2)用private实现的最大特征是：只允许本类访问，不允许外部类访问

• 构造方法：
  （1）方法名需与类名相同；
  （2）构造方法没有返回值类型声明
  （3）每一个类中至少存在一个构造方法；若没有明确定义，则系统会自动生成一个无参构造

  （4）若类中已定义了构造方法，则默认的无参构造将不再生成；

为什么构造方法无返回值，却没有用void声明？
解：类是由 属性、构造方法、普通方法  组成；
属性：是指在对象开辟堆内存时开辟的空间；
构造方法：是在使用new后调用的；
普通方法：是在空间开辟后，构造方法执行后可以多次调用的；

而  编译器是通过程序的结构来区分普通方法和构造方法的；所以在构造方法前没有返回值类型，以便防止混淆；

匿名对象：不赋给任何对象；则匿名对象不会有任何的栈空间所指向所以使用一次后就成为垃圾空间。

• this

  当方法中的参数与属性名相同时，类中的属性无法正确被赋值，此时则需要this关键字给正确的  对象  赋值；
  【只要在类中方法访问类中属性，则需要this关键字】
  

this调用本类方法分为两种：

• 调用普通方法:this.方法名称（参数)

• 调用构造方法： this(参数）

   在构造方法中     使用this调用构造方法的语句 必须放在  构造方法的   首行；
   在使用this调用构造方法时，需留有出口；
  

• this表示当前对象：

• 只要对象调用了本类中的方法，则this表示当前执行的对象

传统属性：保存在堆内存中，每个对象独享该属性；
共享数学：只需在传统属性前加static关键字；
static属性称为  类属性，其保存在全局数据区的内存里，所有对象都可以对该数据区进行访问；

结论：

访问类属性（static属性）使用  类名.属性名  的格式；
所有的非static属性（实例属性）必须在对象实例化后使用，而static属性不受对象实例化控制，即可以在没有实例化对象的时候执行。

使用static定义的方法，直接通过 类名访问；

有关static重点：

1. 所有的static方法不允许调用非static定义的属性或方法；（若非要在静态中调用非静态，则需要在静态中创建对象，通过对象来调用）
2. 所有的非static方法允许访问static方法或属性；

第二节

1. 代码块：使用{}定义的一段代码。【代码块表示作用域，{}退出后则结束】
   代码块分为四种：
   [ ] 普通代码块：定义在方法中的代码块；
   [ ] 构造块：定义在类中的代码块，不加修饰符；（在构造方法之前加代码块）
   [ ] 静态块：使用static定义的代码块；
   [ ] 同步代码块

2. 在非主类中

   构造块优先于构造方法执行，每产生一个新对象时就调用一次构造块。
   静态块 优先于 构造块 优先于构造方法 ；
   无论产生多少实例化对象，静态块都只执行一次；

3. 在主类中的静态块：

   在主类中定义的静态块，优先于main方法执行
   

内部类：

1. 内部类可以访问外部类的成员属性（及类属性）;
2. 若不存在内部类，外部类；例如：Inner类访问Outer类的属性，
   （1）：可以通过在Inner类中创建Outer 类的对象，通过该对象调用方法或成员；

class Inner{
 Outer out=new Outer();
 public void fun() {
  System.out.println(out.getMsg());
 }
}
class Outer{
 String msg="hello xi";
 public String getMsg() {
  return msg;
 }
}
public class Test{
 public static void main(String[] args) {
  Inner in=new Inner();
  in.fun();
 }
}

（2)：在Inner类中创建 参数为Outer 类的对象的 构造方法:

//Inner类访问Outer类属性,通过在一个类中创建另一个类对象的 构造方法；
//在Outer类中创建Inner类的对象；通过对象调用自身方法，打印出Outer类的属性；
class Outer{
 String msg="hello xi";//定义Outer类的属性
 public String getMsg() {
  return this.msg;
 }
 public void fun() {//在该方法中创建Inner类的对象
  Inner in=new Inner(this);//传参
  in.print();//该对象调用该类中的方法
 }
 
}
class Inner{
 private Outer out;
 public Inner(Outer out) {
  this.out=out;
 }
 public void print() {
  System.out.println(out.getMsg());
 }
}
public class Test{
 public static void main(String[] args) {
  Outer out=new Outer();
  out.fun();
 }
}

1. 内部类存在的原因：

   （1）内部类方法可以访问该类定义所在作用域中的数据，包括被private修饰的私有数据；
   （2）内部类可以对同一包中其他类进行隐藏；
   （3）内部类可以实现Java单继承的缺陷；
   

（3）实现单继承缺陷:
通过外部类中的  内部类继承其他类，在外部类中的成员方法中     创建内部类的匿名对象->引用内部类的方法，在创建外部类对象时调用该外部类的成员方法；
class A{
 String name="haha";
 public String getName() {
  return name;
 }
}
class B{
 int age=13;
 public int getAge() {
  return age;
 }
}
class Outer{
 class InnerA extends A{
  public String getName() {
   return super.getName();
  }
 }
 class InnerB extends B{
  public int getAge() {
   return super.getAge();
  }
 }
 public String getName() {//外部类的成员方法
  return new InnerA().getName();
 }
 public int getAge() {
  return  new InnerB().getAge();
 }
}
public class Test{
 public static void main(String[] args) {
  Outer out=new Outer();
  System.out.println(out.getName());
  System.out.println(out.getAge());
 }
}

内部类与外部类的关系：

1. 对于非静态内部类，内部类的创建依赖外部类的实例对象；【必须先创建外部类对象，再通过外部类对象new内部类对象】
2. 内部类可以直接访问外部类的元素，但是外部类不可以直接访问内部类的元素；

class Outter {    
private String outName;   
 private int outAge;
	 class Inner {     
   		 private int InnerAge;   
       		  public Inner() {        
           	  Outter.this.outName = "I am Outter class";    
             	 Outter.this.outAge = 20;     
         		  }     
         public void display() {         
            System.out.println(outName);        
            System.out.println(outAge);   
         } 
     }
}
public class Test {  
  public static void main(String[] args) {  
        Outter.Inner inner = new Outter().new Inner();     
        inner.display();  
      }  }

4. 外部类可以通过内部类 引用 间接访问内部类元素

class Outter {   
 public void display() {       
  // 外部类访问内部类元素，需要通过内部类引用来访问     
     Inner inner = new Inner();    
     inner.display();   
   }   
    class Inner {    
        public void display() {     
         System.out.println("I am InnerClass");      
           }    } }
public class Test {  
  public static void main(String[] args) {   
       Outter out = new Outter();    
        out.display();   
     } } 

1. 内部类的分类：

• 成员内部类

• 静态内部类

• 方法内部类

• 匿名内部类

   （1）在使用内部类的时候创建内部类：
   外部类.内部类.内部类对象=new 外部类().new 内部类();
   （2）在外部类内部创建内部类：
   例：Innner in=new Inner();