Java程序设计 面向对象

小旺不正经
158 阅读5分钟

Java程序设计 面向对象

面向对象的3个特征

封装、继承、多态

类与对象

面向对象中类和对象是最基本、最重要的组成单元。

类是表示一个某类群体的一些基本特征。

对象是表示一个具体的东西。

举例：

人可以表示为一个类，人本身属于一种广义的概念，不是一个具体的。

而某一个具体的人，可以称为对象。

类的定义

class 类名称:{
	数据类型 属性;
	public 返回值的数据类型 方法名称（参数1,参数2...）{
		程序语句;
		[return 表达式;]
	}
}

class Son{
    String name;
    int age;
    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}

对象的创建及使用

类名 对象名称 = null;
对象名称 = new 类名();

类名 对象名称 = new 类名();

class Son{
    String name;
    int age;
    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        a.age=20;
        a.name="xiaowang";
        a.tell();
    }
}

image-20220110222706959

访问对象中的属性、方法

对象名称.属性名
对象名称.方法名()

 		Son a=new Son();
      	a.age=20;
        a.name="xiaowang";
        a.tell();

public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        a.tell();
    }
}

image-20220110223212798

创建多个对象

class Son{
    String name;
    int age;
    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        Son b=new Son();
        a.age=20;
        b.age=30;
        a.name="xiao";
        b.name="xi";
        a.tell();
        b.tell();
    }
}

image-20220110223637682

对象引用传递

class Son{
    String name;
    int age;
    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        a.age=20;
        a.name="xiao";
        Son b=a;
        b.name="xi";
        a.tell();
        b.tell();
    }
}

image-20220110224113687

两个对象的输出内容是一样的，实际上所谓的引用传递，就是将一个堆内存空间的使用权给多个栈内存空间，每个栈内存空间都可以修改堆内存的内容

封装

封装性是面向对象的第一大特性，所谓的封装性就是指对外部不可见

使用封装

private 属性类型 属性名称;
private 方法返回值 方法名称(参数列表){}

class Son{
    private String name;
    private int age;
    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        a.age=20;
        a.name="xiao";
        a.tell();
    }
}

image-20220110230654362

不能由对象直接进行访问

只要是被封装的属性，则必须通过setter和getter方法设置和取得

class Son{
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        a.setAge(20);
        a.setName("xiao");
        a.tell();
    }
}

image-20220110231023523

设限

class Son{
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if(age>0 && age<200) {
            this.age = age;
        }else {
            this.age=1;
        }
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son();
        a.setAge(210);
        a.setName("xiao");
        a.tell();
    }
}

image-20220110232441095

设置年龄时进行判断

构造方法

class 类名称{
	访问权限 类名称(类型1 参数1,类型2 参数2,...){
		程序语句;
	}
}

构造方法的名称必须与类名称一致

构造方法的声明处不能有任何返回值类型的声明

不能在构造方法中使用return返回一个值

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if(age>0 && age<200) {
            this.age = age;
        }else {
            this.age=1;
        }
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
        Son a=new Son("xiao",20);
        a.tell();
    }
}

image-20220111155246747

匿名对象

“匿名对象”，就是没有明确给出名字的对象。一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

class Son{
    private String name;
    private int age;
//    定义构造方法
    public Son(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if(age>0 && age<200) {
            this.age = age;
        }else {
            this.age=1;
        }
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void tell(){
        System.out.println("姓名:"+name);
        System.out.println("年龄:"+age);
    }
}
public class Hello {
    public static void main(String[] args) {
//        匿名对象
        new Son("xioa",20).tell();
    }
}

image-20220111161748261

this关键字

使用this强调本类中的方法

表示类中的属性

可以使用this调用本类的构造方法

this表示当前对象

static关键字

如果使用一个类要分别开辟栈内存及堆内存，在堆内存中要保存对象中的属性，每个对象有每个对象自己的属性，如果现在有些属性希望所有对象共享，则就必须将其声明为static属性。如果一个类中的方法不想由对象，而是由类名称直接调用，则就可以声明为static方法。

使用static声明属性

class Test1{
    String t="A";
    public void p(){
        System.out.println(this.t);
    }
}
class Test2{
    static String t="A";
    public void p(){
        System.out.println(this.t);
    }
}
public class Hello {
    public static void main(String[] args) {
        Test1 t1=new Test1();
        Test1 t2=new Test1();
        Test1 t3=new Test1();
        t1.t="b";
        t1.p();
        t2.p();
        t3.p();
        Test2 t4=new Test2();
        Test2 t5=new Test2();
        Test2 t6=new Test2();
        t4.t="b";
        t4.p();
        t5.p();
        t6.p();
    }
}

image-20220111182314797

修改static属性的值 所有带有该属性的值 都跟着改变

使用static声明方法

class Test{
    private static String t="A";
    public static void setT(String s){
        t=s;
    }
    public void p(){
        System.out.println(t);
    }
}
public class Hello {
    public static void main(String[] args) {
        new Test().p();
        Test.setT("B");
        new Test().p();
    }
}

image-20220111185004049

非static声明的方法可以去调用static声明的属性或方法的。但是static声明的方法是不能调用非static类型声明的属性或方法的。

对象数组

所谓的对象数组，就是指包含了一组相关的对象，但是在对象数组的使用中读者一定要清楚一点：数组一定要先开辟空间，但是因为其是引用数据类型，所以数组里面的每一个对象都是null值，则在使用的时候数组中的每一个对象必须分别进行实例化操作。

对象数组声明

类 对象数组名称[] = new 类[数组长度]

class Son{
    private String name;
    public Son(String nane){
        this.name=nane;
    }
    public String getName(){
        return this.name;
    }
}
public class Hello {
    public static void main(String[] args) {
        Son s[] = new Son[5];
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
        s[0]=new Son("A");
        s[1]=new Son("B");
        s[2]=new Son("C");
        s[3]=new Son("D");
        s[4]=new Son("E");
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i].getName());
        }
    }
}

image-20220112140629675

内部类

在类内部可定义成员变量与方法，有趣的是，在类内部也可以定义另一个类

内部类可声明成public或private。当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同

标识符 class 外部类的名称{
	//外部类的成员
	标识符 class 内部类的名称 {
		//内部类的成员
	}
}

class T{
    private String a="hello";
//    定义内部类
    class S{
//        内部类的方法
        public void print(){
            System.out.println(a);
        }
    };
    public void f(){
//        通过内部类对象调用方法
        new S().print();
    }
}
public class Hello {
    public static void main(String[] args) {
        new T().f();
    }
}

image-20220112144426134

使用static声明内部类

class T{
    private static String a="hello";
    static class f{
        public void print(){
            System.out.println(a);
        }
    }
}
public class Hello {
    public static void main(String[] args) {
        new T.f().print();
    }
}

image-20220112145707777

在外部访问内部类

外部类.内部类 内部类对象 = 外部类实例.new 内部类();

class T{
    private static String a="hello";
    class f{
        public void print(){
            System.out.println(a);
        }
    }
}
public class Hello {
    public static void main(String[] args) {
        T a =new T();
        T.f b = a.new f();
        b.print();
    }
}

image-20220112150101050

avatar
文章
阅读
粉丝