Java学习笔记（一）——|Java学习笔记（一）—— 基础概念篇 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(); } }