Java学习笔记（一）—— 基础概念篇

1. 方法重载

在Java中通过在类中写多个方法，这类方法的方法名相同，方法的参数列表不同（参数的个数和参数类型的不同）来实现方法的重载。所谓方法重载就是：在一个类中，有一系列的方法具有方法名相同，但参数列表不同，这类方法的实现就是方法重载。

public class Test {
    void f(int i) {
        System.out.println("i=" + i);
    }

    void f(float f) {
        System.out.println("f=" + f);
    }

    void f(String s) {
        System.out.println("s=" + s);
    }

    void f(String s1, String s2){
        System.out.println("s1+s2="+(s1+s2));
    }

    void f(String s, int i){
        System.out.println("s="+s+",i="+i);
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.f(3456);
        test.f(34.56f);
        test.f("abc");
        test.f("abc","def");
        test.f("abc",3456);
    }
}

2. 对象

package com.people;

public class People {
//属性（成员变量）有什么
    double height;//身高
    int age;//年龄
    int sex;//性别
//方法 干什么
    void cry() {
        System.out.println("我在哭！");
    }
    void laugh() {
        System.out.println("我在笑!");
    }
    void printBaseMes() {
        System.out.println("我的身高是"+height+"cm");
        System.out.println("我的年龄是"+age+"岁");
        if(this.sex==0)
            System.out.println("我是男性！");
        else 
            System.out.println("我是女性！");
    }
//构造函数,初始化所有属性  
    public People(double h, int a, int s) {
        height = h;
        age = a;
        sex = s;
    }

    public static void main(String[] args) {
        //创建一个People对象LiLei,格式为:类名 对象名=new 类名();
        /*
        People LiLei = new People();
        LiLei.height = 170;
        LiLei.age = 20;
        LiLei.sex = 1;
        */
        
        //创建对象,调用我们自己定义的有参构造方法  ,格式为:类+对象名=new 构造方法/类名(参数);
        People XiaoMing = new People(168, 21, 1);
        XiaoMing.cry();
        XiaoMing.laugh();
        XiaoMing.printBaseMes();
    }
}

运行结果

3. 类

类和对象之间有什么关系吗？在上面的讲解中大家应该有些了解了。类就是对象的抽象(或者模板)，对象就是类的具体（或者实例）。比如手机是一个抽象的概念，它代表着类。而一部 iphone 6 便是手机具象化处理的实体，也就是一个对象。

public class People {
//属性（成员变量） 有什么
    double height;  //身高
    int age;     //年龄
    int sex;    //性别，0为男性，非0为女性

//方法 干什么
    void cry(){
        System.out.println("我在哭！");
    }
    void laugh(){
        System.out.println("我在笑！");
    }
    void printBaseMes(){
        System.out.println("我的身高是"+height+"cm");
        System.out.println("我的年龄是"+age+"岁");
        if(this.sex==0)
            System.out.println("我是男性！");
        else 
            System.out.println("我是女性！");

    }
}

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为static类型。

4. Java三大特征之一——封装

什么是封装?

封装是指，一种将抽象性函式接口的实例细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制，通过该类提供的方法来实现对隐藏信息的操作和访问。
我们在开汽车的时候，只用去关注如何开车，我们并不在意车子是如何实现的，这就是封装。

如何实现?

修改属性的可见性，在属性的前面添加修饰符(private)

对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问

在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定。

package com.newpeople;

public class NewPeople {
//属性(成员变量) 前面添加了访问修饰符private, 变成了私有属性,必须通过方法调用
    private double age;
    
//属性封装好后,用户调用属性需要用getter和setter方法调用,自己定义这两种方法
    public double getAge() {
//方法命名是get关键字加属性名（属性名首字母大写）
        return age;
    }
    public void setAge(double newAge) {
        age = newAge;
    }
    public static void main(String[] args) {
        //创建新的对象XiaoBai
        NewPeople XiaoBai = new NewPeople();
        //访问类里面私有的属性
        XiaoBai.setAge(20);
        System.out.println("XiaoBai age is: "+XiaoBai.getAge());
    }
}

5. 包

有何作用?

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。

包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

如何使用？

比如我们要导入People这个类。import com.People，同时如果import com.People.*这是将包下的所有文件都导入进来，*是通配符。
注意：包的命名规范是全小写字母拼写。

6. 访问修饰符

修饰符	当前类	同一包内	子孙类	其他包
public	Y	Y	Y	Y
protected	Y	Y	Y	N
default	Y	Y	N	N
private	Y	N	N	N

7. 内部类

什么是内部类？

可以将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。

有什么作用？

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

内部类的方法可以直接访问外部类的所有数据，包括私有的数据

内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

内部类允许继承多个非接口类型
注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

成员内部类和静态内部类

成员内部类不能含有static的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

静态内部类通常被称为嵌套类。

package com.packaging;

//外部类Packaging
public class Packaging {
    private String name = "XiaoLi";     //定义外部类私有属性
    static String ID = "20201212";      //定义静态外部类属性
    
    //成员内部类Student
    public class Student{
        String ID = "20180119";         //定义内部类成员属性
        public void stuInfo() {         //定义内部类方法
            System.out.println("访问成员外部类中的name: " + name);
            System.out.println("访问成员内部类中的ID: " + ID);
        }   
    }
    
    //静态内部类Teacher
    public static class Teacher{
        String ID = "20151314";         //静态内部类属性
        public void teaInfo() {         //静态内部类方法
            //静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
            System.out.println("访问外部类中的name: " + (new Packaging().name));
            //如果外部类的静态成员与内部类的成员名称相同，可通过 类名.静态成员 访问外部类的静态成员
            System.out.println("访问静态外部类中的ID: " + Packaging.ID);
            System.out.println("访问静态内部类中的ID: " + ID);
        }
        
    }
    
    public static void main(String[] args) {
        //测试成员内部类
        Packaging a = new Packaging();  //创建外部类对象,对象名为a
        Student b = a.new Student();    //使用外部类对象创建内部类对象,对象名为b
        b.stuInfo();                    //调用内部对象的suInfo方法
        
        //测试静态内部类
        //创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类()
        Teacher c = new Teacher();      //直接创建内部类对象,对象名为c
        c.teaInfo();                    //调用静态内部类方法
        
    }
}

局部内部类

局部内部类，是指内部类定义在方法和作用域内。

package com.packaging2;

//外部类Packaging2
public class Packaging2 {
    //定义在外部类中的方法内：
    public void peopleInfo() {
        final String sex = "man";       //外部类方法中的常量
        class Student{
            String ID = "20151314";     //内部中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex: " +sex);
                System.out.println("访问内部类中的变量ID：" + ID);
            }
        }
        Student a = new Student();      //创建方法内部类的变量
        a.print();                      //调用内部类的方法
    }
    
    //定义在外部类中的作用域内:
    public void peopleInfo2(boolean b) {
        if(b) {
            final String sex = "man";
            class Student{
                String ID = "20151314";
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex: " +sex);
                    System.out.println("访问内部类中的变量ID：" + ID);
                }
            }
            Student a = new Student();
            a.print();
        }
    }
    
    public static void main(String[] args) {
        Packaging2 b = new Packaging2();
        System.out.println("定义在方法内:----------------");
        b.peopleInfo();
        System.out.println("定义在作用域内:--------------");
        b.peopleInfo2(true);
    }
}

匿名内部类

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

8. Java三大特征之一——继承

继承可以看成是类与类之间的衍生关系。比如狗类是动物类，牧羊犬类又是狗类。于是我们可以说狗类继承了动物类，而牧羊犬类就继承了狗类。于是狗类就是动物类的子类（或派生类），动物类就是狗类的父类（或基类）。
继承需要符合的关系是：父类更通用，子类更具体。
语法：class 子类 extends 父类

Animal.java

package com.animal;

public class Animal {
    public int legNum;
    
    public void speak(){
        System.out.println("我是动物!");
    }
    
    public Animal() {
        System.out.println("我是父类!");    
    }
}

Dog.java

package com.animal;

public class Dog extends Animal {
    
    public void speak(){
        System.out.println("I have " + legNum + " legs!");
        System.out.println("我是藏獒!");
    }
    
    public Dog() {
        System.out.println("我是子类!");
    }
    
    public static void main(String[] args) {
        Animal a = new Animal();
        Dog b = new Dog();
        Animal c = new Dog();
        
        System.out.println("------------");
        a.speak();
        System.out.println("------------");
        b.legNum = 4;
        b.speak();
        System.out.println("------------");
        c.speak();
        System.out.println("------------");
        new Dog();
        System.out.println("------------");
    }
}

运行结果

为什么当程序执行到a.speak();的时候,会有五个输出呢?

断点在1位置时

断点在2位置时.说明调用子类前,先调用父类

断点在3位置时.跟上图同理

9. Java三大特征之一——多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。通俗地讲，多态只通过父类就能够引用不同的子类。
注：不能使用一个子类的引用去指向父类的对象。因此，向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写。（方法名，参数都相同）

Animal a = new Animal();  //a是父类的引用指向的是本类的对象 
Animal b = new Dog();     //b是父类的引用指向的是子类的对象

Java多态实现三个条件：继承、重写和向上转型
多太实现方式:
继承父类进行方法重写，抽象类和抽象方法，接口实现。
抽象方法&抽象类

抽象方法: 即只声明而没有方法(类似于C语言的在main函数前的函数声明), 例如: abstract void function
抽象类: 含有抽象方法的抽象类, 抽象方法一般在父类, 这里子类就可以去实现这些方法.

创建抽象类:

勾选abstract
Computer.java

package com.computer;
//注意:类声明\方法生命都要加入abstract
public abstract class Computer {
    public abstract void computerNum();
    public abstract void computerType();
    public abstract void computerEffect();
}

Laptop.java

package com.computer;

public class Laptop extends Computer{
    public void computerNum() {
        System.out.println("There are three laptop!");
    }
    
    public void computerType() {
        System.out.println("They are notebook computer!");
    }
    
    public void computerEffect() {
        System.out.println("They could be taken anywhere!");
    }
    
    public static void main(String[] args) {
        Computer cp = new Laptop();
        cp.computerNum();
        cp.computerType();
        cp.computerEffect();
    }
}

运行结果

部分内容转自实验楼

Java学习笔记（一）—— 基础概念篇

1. 方法重载

2. 对象

3. 类

4. Java三大特征之一——封装

5. 包

6. 访问修饰符

7. 内部类

8. Java三大特征之一——继承

9. Java三大特征之一——多态

你可能感兴趣的:(Java学习笔记（一）—— 基础概念篇)