标题图
构造函数实例
class Cat{
// 设置私有的属性 nameprivate String name; // 设置name的方法
public void setName(String Name) { this.name = Name;
} // 设置获取name的方法
public String getName() { return this.name;
} // 设置不带参数的构造方法
public Cat() {
System.out.println("This is a cat");
} // 设置带参数的构造方法
public Dog(String Name) { this.name = Name;
System.out.println("This is a cat "+name);
} // 定义一个方法
public void sleep(){
System.out.println(this.name+ "is sleeping");
}
}测试类
// 测试类class CatTest {
public static void main(String[] args) { // 定义对象
Cat cat1 = new Cat();
cat1.setName("buling");
cat1.sleep();
Cat cat2 = new Cat("LiLi");
cat2.sleep();
}
}静态方法
class Demo {
// 定义一个函数
public void fun1() {
System.out.println("Hello");
} // 定义一个静态函数
public static void fun2() {
System.out.println("hello");
}
}public class DemoTest {
public static void main(String[] args) {
// 创建对象
Demo d = new Demo();
d.fun1(); // 对静态函数进行调用
Demo.fun2();
// 创建对象
Demo d2 = new Demo();
d2.fun2();
}
}静态修饰的调用方式：1）类名.方法名；2）对象.方法名
继承
案例
在现实世界当中，继承就是儿子得到老子的东西，在面向对象的世界当中，继承就是一个类得到了另一个类当中的成员变量和成员方法
Java只支持单继承，不允许多继承，继承是为了减少重复代码
使用super调用父类构造函数的方法
class Person{// 定义属性String name;int age;// 无参构造函数Person(){
System.out.prinltn("Person的无参数构造函数");
}// 有参的构造函数Person(String name,int age){ this.name=name; this.age=age;
System.out.println("Person有参数的构造函数");
}// 定义的方法void eat(){
System.out.println("定义吃饭的方法");
}
}class Student extends Person{//子类继承父类Student(){ //父类
super();
System.out.println("Student的无参数构造函数");
}
Student(String name,int age,int id){ super(name,age); this.id=id;
}
}在Java中的继承，其实就是继承全部属性和方法(除了构造方法)，除了private修饰的变量或者方法，子类无法进行访问
格式：
[类修饰符] class 子类名 extends 父类名{ ... ...}如：
class Student extends People{ ... ...}类的继承：Object->People->Student
Java中的类只支持单继承，不支持多继承。
类成员的继承：
对于继承：一个类中有成员变量和方法。
子类继承父类，可以有部分继承它的父类，也可以自己定义。
子类能继承
public和protected的成员变量，不能继承private的成员变量，可以继承同包中的默认修饰符。
同理，子类继承父类的方法，能够继承
public和protedted的方法，不能继承private的方法，不能继承构造方法。
封装
封装为了提稿代码的复用性，隐藏了实现的细节，提供对外的访问。
// 老婆类class Woman {
// 定义属性
private String name; private int age; // 私有丈夫
private Man husband; // 获取老婆名字
public String getName() { return name;
} // 设置老婆名字
public void setName(String name) { this.name = name;
} // 设置老婆年龄
public void setAge(int age) { this.age = age;
} // 获取老婆年龄
public int getAge() { return age;
} // 设置丈夫
public void setHusband(Man husband) { this.husband = husband;
} // 获取男人，返回男人类
public Man getHusband() { return husband;
}
}// 男人类public class Man {
// 私有化名字
private String name; // 私有化年龄
private int age; // 私有化老婆
private Woman wife; // 设置名字
public void setName(String Name) { this.name = Name;
} // 获取名字
public String getName() { return this.name;
} // 设置年龄
public void setAge(int Age) { this.age = Age;
} // 获取年龄
public int getAge() { return this.age;
} // 设置老婆
public void setWife(Woman wife) { this.wife = wife;
}
}可将这两种方法进行封装。
多态
多态是为了提高功能的扩展性，提高复用，为父类的引用指向了子类的对象，多态，多种形态的体现。
父类引用指向子类对象，并调用子类的覆盖方法，就是多态，注意父类的引用不能随便强加转为子类类型，因为强转可能会出错，在转换前先使用instanceof判断父类是否可以转换为子类
abstract class Animal{ public abstract void eat();
}多态原理：
Dog d = new Dog(); Animal a = new Dog(); Cat c = new Catt(); Animal aa = new Cat();
多态是同一种行为的不同表现形式或形态的能力。
多态步骤
有继承关系；
子类要重写父类的方法；
父类要指向子类的引用
案例
// 抽象动物类abstract class Animal {
// 抽象的方法
abstract void eat();
}
// 子类继承父类class Cat extends Animal {
// 重写了父类的方法
public void eat() {
System.out.println("吃鱼~");
}
// 添加了功能
public void work() {
System.out.println("抓老鼠~");
}
}
// 子类继承了父类class Dog extends Animal {
public void eat() {
System.out.println("吃骨头~");
}
// 添加了自己的功能
public void work() {
System.out.println("看家~");
}
}// 测试类public class DemoTest { public static void main(String[] args) {
// 父类指向子类的对象
// 向上转型
Animal a = new Cat();
// 调用 Cat 的 eat方法
a.eat();
// 现行判断
if(a instanceof Cat) { // 向下转型
Cat c = (Cat)a;
// 调用 Cat 的 work 方法
c.work();
} else if(a instanceof Dog) {
Dog d = (Dog)a;
d.work();
}
}
}包
在
java中提供了不同的类和接口存放在不同的包中。
常见的包
java.appletjava.awtjava.netjava.utiljava.langjava.io
包的格式：
package 包名[.子包名[…]];
引入java包
import 包层次结构的类名;
Java package提供了访问权限和命名的管理机制，是Java中非常重要的一个概念。为了使包名保持唯一性，通常采用小写、按倒写公司网址的形式进行定义；避免使用与jdk提供的包发生冲突的名字。
作者：达叔小生
链接：https://www.jianshu.com/p/2122df9b95ad
随时随地看视频
