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();
}
}
运行结果
