JAVA-面对对象

这篇笔记只是个人的一些见解加上网络上的一些资料写的，可能再某些地方会有问题，请见谅。

面对对象

两个基本概念：类和对象

三大特征：封装，继承，多态

其它关键字：

static，final，this，super

基本概念

类

类的概念：类就好像一个模板，它描述一类对象的行为和状态。

类的成员：属性，方法，构造器，代码块，内部类。

 

对象

对象的概念：对象是类的一个实例，是类的实现。java语言是面向对象的语言，万物皆对象。

class People//定义一个名为“People”的类
{
    String name="张三";//类中有属性name，属性的值是“张三”
    int age=33;//类中有属性age，属性的值是33
    public void eat()//在属性中定义一个名为“eat”行为
    {
        System.out.println(name+"在干饭。");
    }
    public void blindDate()//在属性中定义一个名为“blindDate”行为
    {
        System.out.println(age+"岁的"+name+"相亲。");
    }
}
public class Peopletest {
    public static void main(String[] args)
    {
        People people=new People();//创建并初始化一个对象
        people.eat();//输出：张三在干饭。
        people.blindDate();//输出：33岁的张三相亲。
    }
}

 

三大特征

封装

定义：隐藏对象的属性和实现细节，使本类之外的类中的代码不能随意访问，提高数据的安全性,可以通过set和get方法来读写私有方法，或在本类构造器中初始化。

class A//定义一个类
{
    private int a;
    public void setA(int a)//set加上首字母大写的变量名
    {
        this.a=a;//将形参a的值赋值给这个对象的a
    }
    public int getA()
    {
        return a;//返回这个对象a的值
    }
}
public class packaging {
    public static void main(String[] args)
    {
        A a=new A();//定义并初始化对象
        a.setA(5);
        System.out.println(a.getA());//输出：5
    }
}

继承

定义：继承是就是子类对象继承了父类对象的属性和方法，并且可以在父类的属性和方法的基础上扩展其它新的属性和方法。一个子类继承最好只继承一个父类。所有类默认继承Object类。（要注意构造器的执行顺序，就是要注意在堆内存中是先执行最高级父类的构造器，再执行子类的构造器）

class A//定义一个类
{
   String name="张三";
   public void test()
  {
     System.out.println("1");
  }
}
class B extends A//将A继承给B
{
    public void test()
    {
        System.out.println("2");
    }
    public void eat()
    {
        System.out.println(name+"在干饭");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        B b=new B();
        b.eat();//输出:张三在干饭
        b.test();//输出：2
    }
}

 

构造器

构造方法是一种特殊的方法，用于初始化对象。对象创建时被调用,构造方法不能有返回值。在一个类中构造方法的方法名和类名一致。

两种类型的构造函方法：

1. 默认构造函数(无参数构造函数)在没有定义构造方法的时候会默认有一个无参构造方法。
2. 参数化构造函数

class A
{
    public A()//定义一个无参构造方法
    {
        System.out.println("555");
    }
    public A(int a)//定义一个有参构造方法
    {
        System.out.println("666");
    }
}

public class test1 {
    public static void main(String[] args)
    {
        A a2=new A();
        A a1=new A(5);
        /*输出：
        *555
        *666
        * */
    }
}

 

重写(Override)与重载(Overload)的区别

重载：是指在一个类中定义多个构造器，通过构造器所带的参数来决定在对象初始化的时候该执行哪个构造器，如果对象初始化的时候没有找到对应参数的构造器就会报错。

class A
{
    public A()//定义一个无参数的构造器
    {
        System.out.println("555");
    }
    public A(String a,int b)//定义一个双参数的构造器
    {
        System.out.println("777");
    }
    public A(int a,String b)//这不是上面的构造器，参数类型的位置不一样
    {
        System.out.println("888");
    }
    public A(int a,String...b)//"..."可以将第二个参数及后面的参数汇聚到一个数组中，这个数组是String类型的
    {
        System.out.println(b[1]);
        System.out.println("666");
    }
    public A(String b,int...a)
    {
        System.out.println(a[1]);
        System.out.println("666");
    }
}

public class test1 {
    public static void main(String[] args)
    {
        A a1=new A();
        A a2=new A("222",5,10);
        A a3=new A(5,"222","11");
        A a4=new A("222",5);
        A a5=new A(5,"9");
       /* 输出:
        10
        666
        11
        666
        777
        888*/
    }
}

 

 

重写：是指在子类继承父类的方法和属性时，将要继承的父类的方法或者属性进行修改。

重写规则：

1. 不过参数要和父类定义的参数一样
2. 返回类型修改必须是父类返回类的子类
3. 访问的权限不能比父类的访问权限高（default（就是不写权限符）>protected>public）
4. 只能被这个父类的子类重写
5. final和private修饰的方法不能被重写。
6. static的方法不能重写，不过可以声明。

class A
{
    Object test()
  {
     System.out.println("1");
     return new Object();
  }
}
class B extends A
{
    protected String  test()
    {
        System.out.println("2");
        return "9999";
    }
}
class C extends B
{
    public String test()
    {
        System.out.println("3");
        return "8888";
    }
}
public class test1 {
    public static void main(String[] args)
    {
        C c=new C();
        System.out.println(c.test());
        /*输出
        * 3
        * 8888*/
    }
}

 

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

访问权限的区别

访问权限	本类	本包的类	子类	非子类的外包类
public	是	是	是	是
protected	是	是	是	否
default	是	是	否	否
private	是	否	否	否

多态

定义：多态是同一个行为具有多个不同表现形式或形态的能力。继承是实现多态的基础。

 

 

class People
{
    String name;
    public void work(){}
}
class Worker extends People
{
    String name="工人";
    public void work()
    {
        System.out.println(name+"在打工");
    }
}
class Teacher extends People
{
    String name="老师";
    public void work()
    {
        System.out.println(name+"在教书");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        People worker=new Worker();//向上转型
        worker.work();//调用的是Worker的work
        Worker a=(Worker)worker;//向下转型
        a.work();//调用的是Worker的work
        People worker1=new Worker();//向上转型，子类内存赋给父类类型的变量
        worker1.work();//调用的是Worker的work
        Teacher a1=(Teacher)worker;//向下转型，一定要注意类型的变化，不能将工人的内存赋给老师类型变量，否则会出错。
        a1.work();
        /*
        输出：
        工人在打工
        工人在打工
        工人在打工
        Exception in thread "main" java.lang.ClassCastException: Worker cannot be cast to Teacher
        at test1.main(test1.java:27)*/
    }
}

 

抽象类

抽象类即在不同类的结构里面增加抽象方法的组成部分。抽象类无法被直接实例，需要被子类继承，不过可以通过子类向上转型处理。抽象类中的抽象方法一定要被继承的子类实现。可以继承的情况是继承这个抽象类的类还是抽象类，不过最后一定要实现。抽象类只可以设置public和protected两种权限，默认public。

abstract class A
{
    abstract void eat();
    public void sleep()
    {
        System.out.println("睡觉");
    }
}
class B extends A
{
    @Override//重写标志
    void eat() {
        System.out.println("干饭");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        B b=new B();
        b.eat();
        b.sleep();
        A a=new B();
        a.eat();
        a.sleep();
        /*
        输出：
        干饭
        睡觉
        干饭
        睡觉
        */
    }
}

 

 

接口

接口就好像功能插件，接口可以给类添加不同的功能，不过这些功能怎么做需要这个类自己来写。

在接口中定义的变量默认为常量。类继承接口时，接口中的方法一定要全部实现。

定义接口：

interface 接口名{
}

使用接口

class 类名 implements 接口1(,接口2...){
}

例子

interface Fly{
    public abstract void fly();//接口中的方法可以不写方法体，直接用";"结束
}
class People implements Fly
{
    public void fly()
    {
        System.out.println("人能飞了");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        People a=new People();
        a.fly();//输出：人能飞了
    }
}

须注意

class A
{
    String name="张三";
    public void sleep()
    {
        System.out.println(name+"睡觉");
    }
    public void eat()
    {
        System.out.println(name+"干饭");
    }
}
class B extends A
{
    String name="李四";
    public void eat() {
        System.out.println(name+"干饭");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        B b=new B();
        b.eat();
        b.sleep();
        /*输出：
          李四干饭
          张三睡觉
          */
    }
}

其它关键字

static（静态）

被staic修饰的变量或方法在类初始化时会被优先执行，不过只会执行一遍，此类的多个实例共享这一个内存。

class A
{
    static int a=5;
}
public class test1 {
    public static void main(String[] args)
    {
        A a1=new A();
        A a2=new A();
        a1.a++;
        System.out.println(a2.a);//输出：6
    }
}

final（最终的）

最终的，不可被修改。

修饰类时，这个类不能被继承。

修饰方法时，这个类不能被子类重写。（类的private方法会隐式地被指定为final方法）

修饰变量时，这个变量一旦被初始化后就不能再修改值。

被static和final一起修饰的变量被称为常量。

 

this

在非静态方法中可以使用，表示本类。

 

class A
{
    String name="张三";
    public A()
    {
        this(5);//调用带参类型为int型的本类构造器
    }
    public A(int a)
    {
        System.out.println("666");
    }
    public void sleep(String name)
    {
        System.out.println(this.name+"睡觉");
        System.out.println(name+"睡觉");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        A b=new A();
        b.sleep("李四");
        /*输出：
        666
        张三睡觉
        李四睡觉
        */
    }
}

super

在非静态方法中可以使用，表示父类。

class A
{
    String name="张三";
    public A()
    {
    }
    public A(int a)
    {
        System.out.println("666");
    }
}
class B extends A
{
    String name="李四";
    public B(){}
    public B(int a){super(5);}//调用父类中参数类型为int型的构造器
    public void sleep()
    {
        System.out.println(name+"睡觉");
        System.out.println(super.name+"睡觉");
    }
}
public class test1 {
    public static void main(String[] args)
    {
        B b=new B(5);
        b.sleep();
        /*输出：
        666
        李四睡觉
        张三睡觉
         */
    }

 

 

this()和super()为构造方法，作用是在JVM堆中构建出一个对象。因为避免多次创建对象，所以一个方法只能调用一次this()或super()。this()和super()的调用只能写在构造器的第一行，避免操作对象时对象还未构建成功。而且this()和super()不能同时出现。