Java面向对象介绍1

1.类和对象的定义格式

类的定义：
class 类名称{
属性名称;
返回值类型 方法名称(){}
}

//对象的定义：
//一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下：
//类名称 对象名称 = new 类名称() ;

//如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：
//访问类中的属性：对象.属性 ;
//调用类中的方法：对象.方法();

//在java中对象声明有两种含义
//声明对象：
//表示声明了一个对象，但是此对象无法使用，horse没有具体的内存指向
User user= null;
// 表示实例化了对象，可以使用
实例化对象：
user= new User() ;
user.eat(); //通过对象调用方法
new User().eat();//匿名对象调用方法

  
 

2.封装

封装性的概念
封装性是面向对象思想的三大特征之一，封装就是隐藏实现细节，仅对外提供访问接口。实现细节部份包装、隐藏起来的方法。
封装有：属性的封装、方法的封装、类的封装、组件的封装、模块化封装、系统级封装…
封装的好处：模块化、信息隐藏、代码重用、插件化易于调试、具有安全性
封装的缺点：会影响执行效率

封装之前：属性都可以直接访问和修改
class Person{
String name;
int age;
}

封装之后：
class Person{
//属性是成员变量，私有化属性，使得其他对象不能直接访问属性
private String name;
private int age;
//参数及方法内定义的变量是局部变量
public void setName(String name){
this.name = name;}
public String getName(){
return name;}
}

成员变量和局部变量的区别
a、在类中的位置不同
成员变量：在类中定义
局部变量：在方法中定义或者方法的参数
b、在内存中的位置不同
成员变量：在堆内存(成员变量属于对象，对象进堆内存)
局部变量：在栈内存(局部变量属于方法，方法进栈内存)
c、生命周期不同
成员变量：随着对象的创建而存在，随着对象的销毁而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
d、初始化值不同
成员变量：有默认初始化值，引用类型默认为null
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用
注意：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

  

3 构造方法

无参构造方法：
public Dog(){} //如果一个类没有定义构造方法，则默认无无参构造，如果有定义有参构造，最好再显示定义一个无参构造方法

带参构造方法：
public Dog(String name){
this.name = name;
}

多参构造方法：
public Dog(String name,int age){
this.name = name;
this.age = age;
}

（1）构造方法名称与类名相同，没有返回值声明（包括 void）
（2）构造方法用于初始化数据（属性）
（3）每一个类中都会有一个默认的无参的构造方法
（4）如果类中有显示的构造方法，那么默认构造方法将无效
（5）如果有显示的构造方法，还想保留默认构造 方法，需要显示的写出来。
（6）构造方法可以有多个，但参数不一样，称为构造方法的重载
（7）在构造方法中调用另一个构造方法，使用this(...)，该句代码必须在第一句。
（8）构造方法之间的调用，必须要有出口。
（9）给对象初始化数据可以使用构造方法或setter方法，通常情况下，两者都会保留。
（10）一个好的编程习惯是要保留默认的构造方法。（为了方便一些框架代码使用反射来创建对象）
（11）private Dog(){}，构造方法私有化，当我们的需求是为了 保正该类只有一个对象时（单例模式就是私有化构造器）。

 

4. this关键字

this关键字指向的是当前对象的引用
调用类中的属性：this.属性名称，指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
调用类中的方法：this.方法名称，用来访问本类的成员方法
调用类构造方法：this();访问本类的构造方法，()中可以有参数的 如果有参数 就是调用指定的有参构造
注意：
1.this() 不能使用在普通方法中，只能写在构造方法中
2.必须是构造方法中的第一条语句

面向对象和构造方法中使用this：
Cat类：
public class Cat {
    private String name;
    private String age;
    //无参构造函数
    public Cat() {
        this("aaaa");
        System.out.println("这是无参构造");
    }
    //有参构造函数
    public Cat(String name,String age) {
        //调用无参构造函数
        this();
        System.out.println("这是有参构造函数");
    }
    
  //构造函数重载：有参构造函数（）
    public Cat(String name) {
        //调用无参构造函数
   
        System.out.println("被无参构造调用了");
    }
    //静态代码块
    static {
        System.out.println("这是静态代码块");
    }
    //普通代码块
    {
        System.out.println("这是普通代码块");
    }        
    public void eat() {
        this.run();
        System.out.println("吃饭");
    }
    
    public void run() {
        System.out.println("小猫快跑");
    }

}

测试方法：
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cat cat=new Cat("阿黄","14");
        cat.eat();
//        执行流程：
//        这是静态代码块
//        这是普通代码块
//        被无参构造调用了
//        这是无参构造
//        这是有参构造函数
//        小猫快跑
//        吃饭

 

5. static关键字

static关键字的作用：方便在没有创建对象的情况下来进行调用（方法/变量）。
a、使用static关键字修饰一个属性：声明为static的变量实质上就是全局变量
b、使用static关键字修饰一个方法：在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法（类调用）
c、使用static关键字修饰一个类（内部类）：
声明为static的方法有以下几条限制：
它们仅能调用其他的static 方法，反过来是可以的。
它们只能访问static数据。
它们不能以任何方式引用this或super。
不允许用来修饰局部变量

 

6.继承

继承是面向对象三大特征之一
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类

被继承的类称为父类（超类），继承父类的类称为子类（派生类）
通过继承可以实现代码重用
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
构造器而言，它只能够被调用，而不能被继承，可以通过使用super()进行调用，
对于继承而已，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要显示的指定父类的构造器（通过super（）），而且必须是在子类构造器中做的第一件事(第一行代码)。
对于protected而言，它指明就类用户而言，他是private，但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言，他却是可以访问的
Java 的继承是单继承，但是可以多重继承，

语法：[访问权限] class 子类名 extends 父类名{
类体定义；
}

示例：
public class Dog{
private String name;
private String sex;
public void eat(){System.out.println(“吃饭”);}
}
public class HomeDog extends Dog{
//类的定义
}
public class HuskyDog extends Dog{
//类的定义
}

protected（受保护的访问权限修饰符，用于修饰属性和方法，使用protected修饰的属性和方法可以被子类继承）

（1）继承是发生在多个类之间
（2）继承使用关键字extends
（3）JAVA只能单继承，允许多层继承
（4）被继承的类叫父类（超类），继承父类的类叫子类（派生类）
（5）在父类中的非私有属性和方法可以被子类继承
（6）protected（受保护的访问权限修饰符），修饰的属性或方法可以被子类继承
（7）构造方法不能被继承
（8）创建对象会调用构造方法，调用构造方法不一定就是创建对象
（9）实例化子类对象，会先调用父类的构造方法，如果父类中没有默认的构造方法，那么子类必须显示的通过super(...)来调用父类的带参构造方法，super也只能在子类构造方法中的第一句

继承的好处：
a、提高代码的复用性
b、提高代码的维护性
c、让类与类之间产生关系，是多态的前提
继承的缺点：增强了类与类之间的耦合性

 

7.对象初始化

public class CodeBlockTest {
public static void main(String[] args) {
Child child = new Child();
}
}
class Father {
public static String fatherStr1 = "fatherStr1（静态字段初始化值）";

public String fatherStr2 = "fatherStr2（字段初始化值）";
static {
System.out.println("父类静态代码块：" + fatherStr1);
fatherStr1 = "fatherStr1（静态代码块赋值）";
}
{
System.out.println("父类构造代码块：" + fatherStr2);
fatherStr2 = "fatherStr2（构造代码块赋值）";
}
public Father() {
System.out.println("父类构造函数块：" + fatherStr2);
fatherStr2 = "fatherStr2（构造函数赋值）";
}
}

class Child extends Father {
public static String childStr1 = "childStr1（静态字段初始化值）";
public String childStr2 = "childStr2（字段初始化值）";
static {
System.out.println("子类静态代码块：" + childStr1);
childStr1 = "childStr1（静态代码块赋值）";
}
{
System.out.println("子类构造代码块：" + childStr2);
childStr2 = "childStr2（构造代码块赋值）";
}
public Child() {
System.out.println("子类构造函数：" + childStr2);
childStr2 = "childStr2（构造函数赋值）";
}
}
// 输出结果：
// 父类静态代码块：fatherStr1（静态字段初始化值）
// 子类静态代码块：childStr1（静态字段初始化值）
// 父类构造代码块：fatherStr2（字段初始化值）
// 父类构造函数块：fatherStr2（构造代码块赋值）
// 子类构造代码块：childStr2（字段初始化值）
// 子类构造函数：childStr2（构造代码块赋值）

   

通过每执行一个代码块或构造函数，输出字段在上一代码块执行后的值，以此来探究对象的初始化顺序。
由目前的输出结果可知，对于对象的初始化顺序，我们可以得出以下结论：

父类静态字段初始化
父类静态代码块
子类静态字段初始化
子类静态代码块
父类普通字段初始化
父类构造代码块
父类构造函数
子类普通字段初始化
子类构造代码块
子类构造函数
8.方法重写

方法重写(overriding method)
在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想做一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
在子类和父类中，重写方法后，在调用时，以创建的对象类型为准，会调用谁的方法。

重写特性：
a、发生在子父类中，方法重写的两个方法返回值、方法名、参数列表必须完全一致（子类重写父类的方法）
b、子类抛出的异常不能超过父类相应方法抛出的异常（子类异常不能大于父类异常）
c、子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)
d、父类中的方法若使用private、static、final任意修饰符修饰，那么，不能被子类重写。

面试题 ：overloading（方法重载）与overriding（方法重写）的区别？

/**
     * 方法重载(overloading)：
     * 1、同一个类中
     * 2、方法名相同，参数列表不同（参数顺序、个数、类型）
     * 3、方法返回值、访问修饰符任意
     * 4、与方法的参数名无关
     *
     * 方法重写(overriding)：
     * 1、有继承关系的子类中
     * 2、方法名相同，参数列表相同（参数顺序、个数、类型）
     * 3、访问修饰符，子类的访问修饰符必须比父类的高或者相等
     * 4、与方法的参数名无关
     * 5、当前返回值void或基本数据类型时，必须相同;当返回值是引用类型时，可以是父类或子类
     */

 

案例：

//==========Animal类(Dog和Cat的父类)=========
public class Animal {

    public int a=10;
    
    public void eat() {
        System.out.println("这是公用类吃方法");
    }
    
    
    public int jump() {
        System.out.println("这是公用类jump方法");
        return 0;
    }
    
    public Animal eat(String name) {
        System.out.println("这是公用类eat带参数方法");
        return new Animal();
    }

}

public class Dog extends Animal{
    
    public int a=20;
    
    //同类下的方法名一样属于重载
    public void eat() {
        System.out.print("这是小狗类吃方法");
    }
    //引用类型时可以使用子类
    public Dog eat(String name) {
        System.out.println("这是小狗类eat带参数方法");
        return new Dog();
    }
    //基本类型只能使用相同的
    public int jump() {
        System.out.println("这是小狗类jump方法");
        return 0;
    }
    
}

public class Cat extends Animal {    
    public int jump() {
        System.out.println("这是小猫类jump方法");
        return 0;
    }
    public Cat eat(String name) {
        System.out.println("这是小猫类eat带参数方法");
        return new Cat();
    }

}

        System.out.println("猫类");
        Cat cat=new Cat();
        cat.eat();
        cat.eat("花花");
        cat.jump();
        System.out.println(cat.a);
        
        System.out.println("狗类");
        Dog dog=new Dog();
        dog.eat();
        dog.eat("小黑");
        dog.jump();
        System.out.println(dog.a);
    

 
//        猫类
//        这是公用类吃方法
//        这是小猫类eat带参数方法
//        这是小猫类jump方法
//        10
//        狗类
//        这是小狗类吃方法这是小狗类eat带参数方法
//        这是小狗类jump方法
//        20

//综上所述：
对象方法/参数存在时使用该类的方法/参数，没有则调用父类的

​
9.访问修饰符

/**
 * private:只允许本类中访问
 * 默认：允许在当前类、同包类访问，跨包类无法使用
 * protected:允许在当前类，同包子类/同包非子类、跨包子类调用，跨包非子类不允许
 * public:允许任意类访问
 */