java学习笔记(1) - 面向对象(1)

1. 创建类和使用类

package chapter02_面向对象;
import java.util.Date; // 导入对应的包(java.lang这个包不需要导入,jvm自动导入)
// import java.util.*; // 引入一个包中所有类

public class oop {
    public static void main(String[] args) {
        // 面向对象
        /*
        *  类(表示归纳的整理)
        *  class 类名(第一个字母一般要大写){
        *       特征(属性)
        *       功能(方法)
        *  }
        *
        * 创建对象语法结构 new
        * */
        Cooking a = new Cooking(); // 前面的数据类型为以对应类为原型限制的对象
        a.name = "红烧牛肉面";
        a.food = "牛肉";

        System.out.println(a.name);// 红烧牛肉面

        a.Process("二十",10,20,30);// 使用多个形参...
    }
}

// 创建一个新类(引用数据类型)
class Cooking{
    // 属性
    String name;
    String food;
    int time = 10;

    // 方法(前面的void为返回值类型,无返回值则写void)
    // 重点:java中的方法传递参数,基本数据类型就直接传数值(栈),引用数据类型就传引用地址(堆)
    void Process(String dur,int... dur1){// int... 为可变函数(一般放置在最后),可以有多个
        System.out.println("准备食材" + food);
        System.out.println("开始烹饪" + name);
        System.out.println("烹饪成功,耗时" + dur+'次' + dur1+'秒');
    }
}

2. 静态代码块和非静态代码块

package chapter02_面向对象;

public class oop {
    public static void main(String[] args) {
        // 面向对象

        // 静态属性和方法的使用
        Bird.fly();
        System.out.println(Bird.type);

        // 该静态属性相较于js,java中同样能够在实例化的对象上使用该属性
        Bird b = new Bird();
        b.fly();
    }
}

// 静态代码块和非静态代码块
// 创建一个类
class Bird{
    // 静态属性(无需new实例化即可使用)
    static String type = "鸟";

    // 静态方法(无需new实例化即可使用)
    static void fly(){
        // 但是静态方法不能访问成员属性和成员方法
        // System.out.println(type1);
        System.out.println("飞...");
    }

    // 静态代码快(该类在加载完成后会自动触发,即只要使用到该类就会触发)
    static {
        // 静态代码块(只会执行一遍)
        System.out.println("该类被调用触发了");
    }
    // 非静态代码块只会在该类被实例化创建对象的时候调用
    {
        System.out.println("该类被实例化了,创建了对象!");
    }
    String type1 = type;
}

3. 引入包 import

package chapter02_面向对象;
import java.util.Date; // 导入对应的包(java.lang这个包不需要导入,jvm自动导入)
// import java.util.*; // 引入一个包中所有类

public class oop {
    public static void main(String[] args) {
        // 面向对象

        Date d = new Date(); // 可以直接创建时间
        System.out.println(d);// 成功输出当前时间
    }
}

4. 构造函数

package chapter02_面向对象;

public class oop {
    public static void main(String[] args) {
        // 面向对象

        // 构造函数
        Man man = new Man("张三");
        System.out.println(man.username); // 可以访问当传递的参数属性
    }
}

// 构造方法
class Man{
    // 设置一个属性
    String username;

    // 构造方法(需要与类名一致),代码块在构造方法之前执行
    // 一般用于对象属性的赋值,如果类中没有构造方法,jvm会在类实例化的时候自动创建
    Man(String name){
        username = name; // 变量赋值
        System.out.println("构造函数执行了...");
    }
}

5. 继承extends,super,this以及多态

package chapter02_面向对象;

public class oop {
    public static void main(String[] args) {
        // 面向对象

        // extends(super this) 继承
        Child child = new Child();
        System.out.println(child.name);// 成功输出父类的name属性 李四
        child.test();// 成功区分 super.name:李四  this.name/name:王五

        // 多态 - 所谓多态就是对象使用继承的时候,在实例化的时候可以选择以继承的类来约束实例化生成的对象
        // 如我可以使用 Father 来约束生成的Child对象
        Father child1 = new Child();
        // 约束生成的对象只能使用约束类(继承父类)中使用的方法以及属性,不能使用实例化类中特有的属性
    }
}

// 继承 extends (子类可以继承父类)
class Father{ // 父类
    String name = "李四";

    // 当父类中的构造方法是自定义的时候就需要在子类的构造方法中调用super()来初始化父类
    Father(int age){}
}

class Child extends Father{
    // 该类中无任何属性和方法时可以继承父类中的属性和方法

    // 但是当子类中有父类的属性或者方法时可以使用 super 和 this(默认)来区分两者
    String name = "王五";

    // 子类中的构造方法需要调用super()来实例化父类
    /*
    * 因为我们知道,继承的实现原理是先将父类实例化,随后再将父类的属性传给实例化后的子类
    * 也就是可以说成先有父亲才有儿子,但是父类在main中并没有实例化,此时该类又是自定义的
    * 构造方法,因此就需要在子类的构造方法中调用super(传递参数),来实例化父类再继承属性给子类
    * */
    Child(){
        super(12); // 在子类的构造方法中调用super(传递参数)来实例化父类
    }

    void test(){
        System.out.println(super.name);// 输出的是父类的name,李四
        System.out.println(this.name);// 输出的是子类类的name,王五(不写的情况下默认是this)
    }
}

6. 方法的重载以及重写

package chapter02_面向对象;
import java.util.Date; // 导入对应的包(java.lang这个包不需要导入,jvm自动导入)
// import java.util.*; // 引入一个包中所有类

public class oop {
    public static void main(String[] args) {
        // 面向对象

        // 方法的重写
        // 所谓方法重写就是在子类继承父类后,父类的某些方法不适用于某些场景,子类可以通过重写来实现应付这些场景的逻辑
        // 这就是方法的重写(在子类中重写一个与父类相同名字的方法,且需要同形参,同返回值)
        Boy boy = new Boy();
        boy.test();// 默认是输出"boy test...",但是使用super关键字后同时输出"parent test..."
    }
}

// 方法重载以及方法重写
// 1. 方法重载: 当一个类中有多个同名的方法时,只要它们的形参不同就可以执行
class M_Reload{
    // 以下三个方法是同名的,但是传入的形参不同,不会报错
    void login(String name){
        System.out.println("test1...");
    }
    void login(int age){
        System.out.println("test2...");
    }
    void login(){
        System.out.println("test3...");
    }

    // 当然构造方法也是有重载的(具体执行那个就看你传入那个参数)
    // 不传入参数就执行第一个,传入username字符串就执行第二个
    M_Reload(){
        // 我们同时可以在一个构造方法中调用另一个构造方法,则是使用this
        this("张三");// 调用了下面的构造方法,实例化的时候输出 "构造方法2执行...张三"
        System.out.println("构造方法1执行...");
    }
    M_Reload(String username){
        System.out.println("构造方法2执行..." + username);
    }
}

// 2. 方法重写: 在继承的时候,子类和父类拥有同一种方法时,可以使用super来调用父类的方法
class Parent{
    void test(){
        System.out.println("parent test...");
    }
}

class Boy extends Parent{
    void test(){
        super.test();// 调用父类的方法
        System.out.println("boy test...");
    }
}

7. 递归以及访问权限

package chapter02_面向对象;

public class oop {
    public static void main(String[] args) {
        // 面向对象

        // 递归的调用
        Sum sum = new Sum();
        System.out.println(sum.sum(10)); // 成功输出55
    }
}

// 递归(所谓递归就是方法调用自身,自己调用自己)
class Sum{
    // 写一个递归方法(计算由1+10的结果)
    int sum(int limit){
        if(limit >= 1){
            return limit + sum(limit - 1);
        }
        return 0;
    };
}

// 访问权限
// TODO 面向对象 - 访问权限
// public : 公共的，访问权限修饰符
//         Java的源码中，公共类只能有一个，而且必须和源码文件名相同
//         main方法：main方法是由JVM调用的，JVM调用时应该可以任意调用，而不用考虑权限问题。

// TODO Java中的访问权限主要分为4种：
//   1. private : 私有的, 同一个类中可以使用且只能在类中使用
//   2. (default) : 默认权限, 当不设定任何权限时，JVM会默认提供权限，包(路径)权限
//   3. protected : 受保护的权限, 子类可以访问
//   4. public : 公共的, 任意使用

访问权限:

• Java一共有四种权限，private (私有)，public（公有）。Protected（受保护）还有default(友好型)。

1. Private：

• 类中的所有private方法和private 成员变量只能在类中访问而不能在其他类中访问。

package Main;

public class Private {
    private int a;
    private int b;
    Protected (){
        this.a=1;
        this.b=2;//a和b只能在Private类中调用
    }
    private void set(){
        System.out.println(""+a+""+b+"\n");
    }
    void Print(){
        this.set();//只能在这里用；
    }
}

2. 友好型(default)和protected:

• **如果在另一个类中声明其他的一个类，如果这两个在一个包中那么另一个类能访问这个其他类的友好型变量不同包不能访问; **
• 如果在另一个B类中声明其他的一个类A，如果这两个在一个包中那么另一个类B也能能访问这个其他类A的protected变量（或方法），如果不在一个包，那么如果类A有一个父类C如果，如果父类C中有一个protected变量（或方法），只要B，C在一个包中，B就能使用A中从父类继承的protected方法。如果A是B的子类，如果AB不在一个包中，那么A可以使用B中protected方法。

package Main;
import Protected.*;
public class Main {
    public static void main(String args[]){
        Protected jkl=new Protected();
        jkl.Print();//调用jkl父类的protect方法
        Frindly prot =new Frindly();
        System.out.println(prot.a);//在Main类中调用友好型的变量
        prot.set();//在Main类中调用友好型的方法
    }
}
package Main;

public class Frindly {
    int a,b,c,d;
    Frindly(){
        a=b=c=d=1;
    }
    void set (){
        System.out.print(""+a+" "+b+"\n");
    }
}
package Main;
public class Protectedfather{
    protected int a;
    private int b;
    protected Protectedfather (){
        this.a=1;
        this.b=2;//a和b只能在Protected中调用
    }
    private void set(){
        System.out.println(""+a+""+b+"\n");
    }
    protected void Print(){
        this.set();//只能在这里用；
    }
}

package Protected;
        import Main.*;
public class Protected extends Protectedfather{
    public Protected(){
        super();//在另一个包中调用里父类中的protect构造方法
        super.a=12;//调用父类的protect变量
    }
}

3. Public:

• 如果类中的方法或者变量是public，那么就可以在别的类中调用，没有限制（用在夸包）。A调用别的包中的B类

package Main;
import Public.*;
public class Main {
    public static void main(String args[]){
        int a;
        Public p=new Public();//调用public类中的public方法
        a=p.a;//调用Public类中的public变量
        p.set();
    }
}
 
package Public;

public class Public {
    public int a=12;
    public void set (){
        System.out.println("OK\n");
    }
}

总结表格：：

	同一类	同包	不同包
	子类	非子类	子类	非子类
private	是	否	否	否	否
default	是	是	是	否	否
protected	是	是	是	是	否
public	是	是	是	是	是