Java面向对象

1.Java类及类的成员

属性、方法、构造器、代码块、内部类。

属性：对应类中的成员变变量。（属性（field）有时又叫成员变量）

行为：对应类中的成员方法。（方法（method）或者成员方法或者函数）

1.创建一个类。

package com.atguigu.practice;

public class PersinoText {
    public static void main(String[] args) {
        
    }
}

class Persion {
    // 属性
    String name;
    int age = 10;
    
    // 方法
    public void chi() {
        System.out.println("只会吃");
    }
}

View Code

2.类的实例化与调用

public class PersinoText {
    public static void main(String[] args) {
        // 创建 Persion 类的对象 
        Persion p1 = new Persion();
        // Persion 类属性的赋值
        p1.name = "Tom";
        // Persion 类方法的调用
        p1.chi();
        // Persion 类方法的传参
        p1.he("面包");
        
        // 修改 Persion 类里的属性
        p1.age = 4;
        // 打印 Persion age的值
        System.out.println(p1.age);
        
    }
}

class Persion {
    // 属性
    String name;
    int age = 10;
    
    // 方法
    public void chi() {
        System.out.println("只会吃");
    }
    // 带变量的方法
    public void he(String eat) {
        System.out.println(name+age+"岁就会自己吃"+eat+"了");
    }
}

View Code

3.多个对象之间的关系

package com.atguigu.practice;

public class PersinoText {
    public static void main(String[] args) {
        // 创建 Persion 类的对象 
        Persion p1 = new Persion();
        // Persion 类属性的赋值
        p1.name = "Tom";
        // Persion 类方法的调用
        p1.chi();
        // Persion 类中he方法形参的传值
        p1.he("面包");
        
        // 修改 Persion 类里的属性
        p1.age = 4;
        // 打印 Persion age的值
        System.out.println(p1.age);
        //************************
        // 在创建一个p2对象，在打印name变量值是多少
        Persion p2 = new Persion();
        System.out.println(p2.name);  // 打印 null
        // 创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static）
        // 意味着如果我们修改p1对象的属性name，不影响p2对象属性的name得知
        //************************
        // 在创建一个 p3 对象赋值 p1 打印 name 变量
        Persion p3 = p1;
        System.out.println(p3.name); // Tom
        // 修改 p1 的 age 值，打印 p1 的 age 值
        p3.age = 1;
        System.out.println(p1.age);
        // 将 p1 变量保存的对象地址值赋给 p3，导致 p1 和 p3 指向了堆空间中的同一个对象实体。
    
    }
}

class Persion {
    // 属性
    String name;
    int age = 10;
    
    // 方法
    public void chi() {
        System.out.println("只会吃");
    }
    // eat 形参
    public void he(String eat) {
        System.out.println(name+age+"岁就会自己吃"+eat+"了");
    }
}

View Code

4.属性（或成员变量）和局部变量

　　1.相同点

　　　　1.定义变量的格式：数据类型。

　　　　2.先声明，后使用。

　　　　3.变量都有其对应的作用域

　　2.在类只能够声明的位置不同

　　　　属性：直接定义在类的一对{}内。

　　　　局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。

　　3.关于权限修饰符的不同

　　　　属性：可以在声明属性时，指明其权限，使用权限修饰符

　　　　常用的权限修饰符：private、public、缺省、protected

5.方法：描述类应该具有的功能

　　方法的声明：权限修饰符返回值类型方法名(形参列表){ 方法体 }

　　1.带返回值的方法和不带返回值的方法

public void eat(){}    // void 不可以接收返回值
public String getName(){} // String 可以接收返回值

View Code

6.形参和实参：

　　形参：方法定义时，声明小括号内的参数。

　　实参：方法调用时，实际传递给形参的数据。

public class day1 {
    public static void main(String[] args) {
        Test t1 = new Test();
        t1.name = "Tom";
        String fhz = t1.getName(10); // 10 是实参（形参赋值），并接受返回值
        System.out.println(fhz);
    }

}

class Test {
    String name;
    // int age 形参
    public String  getName(int age) {
                // return 返回值
        return "我的名字叫："+name+"今年"+age+"岁";
    }
}

View Code

7.匿名对象：创建的对象，没有赋给一个变量名。即为匿名对象。

　　特征：匿名对象只能在创建的时候调用一次

package com.atguigu.java;

public class InstanceTest {
    public static void main(String[] args) {
        PhoneMall pm = new PhoneMall();
        // 匿名函数 new Phone()
        pm.show(new Phone());
        System.out.println("********************");
        // 匿名函数
        new Phone().day = 1999;
        new Phone().whatDay();
    }
}

class PhoneMall{
    public void show(Phone phone) {
        phone.sendEmail();
        phone.showPrice(2000);
    }
}

class Phone{
    int day;
    public void sendEmail() {
        System.out.println("发邮件");
    }
    public void showPrice(int money) {
        System.out.println("手机价格为：" + money);
    }
    public void whatDay() {
        System.out.println("手机买了："+day+"天");
    }
}

View Code

8.重载：同一个类，方法名相同。参数列表不同，参数个数不同，参数类型不同。

class test{
    // 重载 findTest(int[] find)   findTest(String[] find)
    public void findTest(int[] find) {}
    public void findTest(String[] find) {}
}

View Code

9.可变个数的形参：必须声明在参数的末尾。一个方法里只能声明一个可变个数的形参。

public class day1 {

    public static void main(String[] args) {
        day1 d = new day1();
        d.test1("aa","bb","cc");
        System.out.println("**********************");
        d.test2(new String[] {"11","22","33"});
    }
    // 方式一：可变个数的形参 
    public void test1(String ... str) {
        System.out.println(str);
        System.out.println(str[2]);
    }
    // 方式二：
    public void test2(String[] str) {
        System.out.println(str);
        System.out.println(str[2]);
    }
}

View Code

10.变量的赋值：

　　基本数据类型：赋值的是变量所保存的数据值。

　　引用数据类型：赋值的是变量所保存数据的地址值。

public class day1 {

    public static void main(String[] args) {
        System.out.println("***********基本数据类型***********");
        int a = 10;
        int b = a;
        System.out.println("a："+a+",b："+b);
        b = 20;
        System.out.println("a："+a+",b："+b);
        
        System.out.println("***********引用数据类型***********");
        Test t = new Test();
        t.number = 10;
        Test t2 = t;
        System.out.println("t:"+t.number+",t2:"+t2.number);
        t.number = 20;
        System.out.println("t:"+t.number+",t2:"+t2.number);
    }
}
class Test{
    int number;
}

View Code

11.值传递机制

　　如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

　　如果参数是引用数据类型，此时实参附给形参的是实参存储数据的地址值。

public class Bubbling {
    public static void main(String[] args) {
        Bubbling mp = new Bubbling();
        
        int[] number = new int[] {11,14,-1,-14,-56,57,492,68,25};
        for (int i=0;i<number.length;i++) {
            System.out.print(number[i]+" ");
        }
        System.out.println();
        
        // 冒泡
        for(int i=0;i<number.length;i++) {
            for(int j = 0;j < number.length - 1 - i;j++) {
                if (number[j] > number[j+1]) {
//                    int temp = number[j];
//                    number[j] = number[j + 1];
//                    number[j + 1] = temp;
                    // 错误
                    // mp.swap(number[j], number[j + 1]);
                    // 正确
                    mp.swap(number,j,j+1);
                }
            }
        }
        
        for (int i=0;i<number.length;i++) {
            System.out.print(number[i]+" ");
        }
    }
    // 错误的
    public void swap(int i ,int j) {
        int temp = i;
        i = j;
        j = temp;
    }
    // 正确定
    public void swap(int[] arr,int i ,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
}

View Code

12. 构造器

　　构造器的作用：创建对象、初始化属性。

　　1. 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。

　　2.定义构造器的格式，权限修饰符类名(形参列表){}

　　3.一个类中定义的多个构造器，彼此构成重载。

　　4.一旦定义了类的构造器之后，系统就不在提供默认的空参构造器。

　　5.一个类中，至少会有一个构造器。

下面就创建一个简单的构造器。

public class gzq {
    public static void main(String[] args) {
        // 创建类的对象： new + 构造器（Person()）
        Person p = new Person();
    }
}

class Person{
    // 构造器
    public Person() {
        System.out.println("Person()....");
    }
}

View Code

一个类中定义多个构造器。

public class gzq {
    public static void main(String[] args) {
        // 创建类的对象： new + 构造器（Person()）
        Person p = new Person();
        Person p2 = new Person("Tom");
        System.out.println(p2.name);
    }
}

class Person{
    String name;
    // 构造器
    public Person() {
        System.out.println("Person()....");
    }
    public Person(String n) {
        name = n;
    }
}

View Code

2.面向对象的三大特性

封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）

1. 封装：隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。　　

　　　　将方法和属性私有化，只能内部调用。

2. 四种访问权限修饰符

　　　四种权限就可以用来修饰类及类的内部结构：属性、方法、构造器、内部类。

　　　修饰类只能使用：缺省、public。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
(缺省)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

继承：extends

继承就是子类继承父类后，子类就获得父类中声明的所有方法和属性。

// 父类
public class Person {
    String name;
    int age;
    public void eat() {
        System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
}

// 子类
//子类和父类相同的代码注释掉。
public class Student extends Person{
//    String name;
//    int age;
    　String sex;
    
//    public void eat() {
//        System.out.println("吃饭");
//    }
//    public void sleep() {
//        System.out.println("睡觉");
//    }
        public void play() {
        System.out.println("玩。。。");
    }
}

// 测试类
public class ExtendTest {
    public static void main(String[] args) {
        // 父类
        Person p = new Person();
        p.name = "Tom";
        System.out.println(p.name);
        
        // 子类
        Student s = new Student();
        s.name = "Jack";
        System.out.println(s.name);
        s.eat();
        s.sleep();
    }
}

View Code

关于继承性的规定：

一个类可以被多个子类继承。
Java中类的单继承性：一个类只能有一个父类
子类直接继承的父类，称为直接继承，间接继承的父类，称为间接继承。

class a{
}

// b类继承a类
class b extends a{
}

// c类间接继承a类中所有的方法和属性
class c extends b{
}

View Code

如果我们没有显示的声明一个类的父类的话，则此类继承于java.lang.Object类。

3.其他关键字

1.this

可以用来修饰：属性、方法、构造器。

this 理解为：当前对象。
如果方法的形参和类的属性同名时，必须显示的使用"this.变量"的方式。表明此变量是属性，而非形参。
在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是通常情况下，我们都选择省略"this.变量"的方式。

this调用属性和方法：

public class gjz {
    public static void main(String[] args) {
        Persons p = new Persons();
        p.setName("Tom");
        System.out.println(p.getName());
        p.eat();
    }
}

class Persons{
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void eat() {
        System.out.println("人吃饭。。。");
        this.water();
    }
    public void water() {
        System.out.println("人喝水。。。");
    }
}

View Code

this调用构造器

public class gjz {
    public static void main(String[] args) {
        Persons p = new Persons("Tom");
        System.out.println(p.getName());
    }
}

class Persons{
    private String name;
    
    public Persons() {
    }
    public Persons(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

View Code

在类的构造器中，可以显示的使用"this(形参列表)"方式，调用本类中制定的其他构造器。
构造器中不能通过"this(形参类吧)"方式调用自己。
规定："this(形参列表)"必须声明在当前构造器的首行。
构造器内部，最多只能声明一个"this(形参类吧)"，用类调用其他的构造器。

public class gjz {
    public static void main(String[] args) {
        Persons p = new Persons("Tom",18);
        System.out.println(p.getName());
    }
}

class Persons{
    private String name;
    private int age;
    public Persons() {
        System.out.println("Persons....");
    }
    public Persons(String name) {
        this(); // 调用 Persons() 构造器
        this.name = name;
        System.out.println("Persons(String name)....");
    }
    public Persons(String name,int age) {
        // 把 Persons(String name,int age) 构造器中接收的name值，传递给 Persons(String name)构造器
        this(name); // 调用 Persons(String name) 构造器
        System.out.println("Persons(String name, int age)....");
    }
    public String getName() {
        return this.name;
    }
}

View Code

2.package

使用package声明类或接口所属的包，声明在源文件的首行。
包属于标识符，遵循标识符的命名规则、规范(xxyyzz)、"见名知意"。
每"."一次，就代表一层文件目录。

3.import

在源文件中显示的使用import结构导入指定包下的类、接口。
import声明在package下面。
可以使用"java.util.*"的方式，导入"java.util"下的所有结构。
如果使用的类或接口是java.lang包下定义的，则可以省略import结构。
如果使用的类或接口是同一个包下定义的，可以省略import结构。
使用"xxx.*"方法表明可以调用xxx包下的所有结构。但如果使用的是xxx子包下的结构，则仍需要显示调用。
如果在源文件中，使用了不同包下同名的类，则必须至少有一个类需要以全类名的方式显示。

posted @ 2021-07-26 22:15 Amoヽ柠檬阅读(51) 评论(0) 收藏举报

刷新页面返回顶部

Amoヽ柠檬

Java面向对象

1.Java类及类的成员

2.面向对象的三大特性

继承 ：extends

3.其他关键字

1.this

2.package

3.import

公告

继承：extends