1. 包和导包
包:本质是一个文件夹,在代码中需要写package 包名
导包:
import 包 . 类;
不需要导包的情况:
1. 在自己的包内
2.java.long包下的所有内容不需要导包
String
System.out.println()
2. 访问权限
1. public 公共的
2. default 包访问权限,在自己包内可以随意访问,别的包不可访问
3. private 私有的
//com.xyq.entity中 包括类 Person的定义
package com.xyq.entity;
public class Person {
public String pub = "public";
private String pri = "private";
String def = "default";
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.pub);
System.out.println(p.pri);
System.out.println(p.def);
}
}
输出结果:
public
private
default
// com.xyq.entity 中另一个类定义文件
package com.xyq.entity;
public class TPerson {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.pub);
System.out.println(p.pri); //报错
System.out.println(p.def);
}
}
编译结果:
System.out.println(p.pri); 报错
//另一个包 com.xyq.daobao 中
package com.xyq.daobao; //包的声明
import com.xyq.entity.Person; // 导包
public class TestPerson {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.pub);
System.out.println(p.pri); // 报错
System.out.println(p.def); // 报错
}
}
编译结果:
System.out.println(p.pri); System.out.println(p.def);编译报错
用的最多的是 public 和 private 。
3. getter 和 setter
自动生成:右键 -> generate -> getter and setter -> 全选 -> ok。
4. 继承
继承:子类可以自动拥有父类中除了私有内容外的其他所有内容。
当出现 x 是一种 y 的时候,x 就可以继承 y 。
public class 类 extends 父类 {
}
黑熊怪是一种妖怪。
// YaoGuai.java
package com.xyq.yaojing;
public class YaoGuai {
private void paSi(){
System.out.println("妖怪怕死");
}
public void chiRen()
{
System.out.println("吃人");
}
}
// HeiXiongJing.java
package com.xyq.yaojing;
public class HeiXiongJing extends YaoGuai{
}
// test.java
package com.xyq.yaojing;
public class test {
public static void main(String[] args) {
HeiXiongJing hx = new HeiXiongJing();
hx.chiRen();
hx.paSi();
}
}
hx.paSi(); 报错 ---------- 私有内容不能继承
5. super关键字
super:表示父类中的内容
this:表示自己类中的内容
用 super 和 this 区分父类和子类重名的内容。
创建对象的过程: 先创建父类的对象,然后创建子类的对象。
super() ; 调用父类构造方法
this(); 调用本类构造方法
6. 多态
//Animal 是 Cat、Dog、Bird 父类
Animal ani = new Cat(); // 把子类的对象赋值给父类的引用(变量),向上转型
// Animal.java
public class Animal {
public void eat() {
System.out.println("动物在吃");
}
}
// Cat.java
public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
// Dog.java
public class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
}
// Bird.java
public class Bird extends Animal{
public void eat(){
System.out.println("鸟吃米");
}
}
// Person.java
public class Person {
public void feed(Animal ani){ // 接收到的所有动物都是 Animal
ani.eat();
}
public static void main(String[] args) {
Animal ani1 = new Cat(); // 把子类的对象赋值给父类的引用(变量) 向上转型
Animal ani2 = new Dog();
Animal ani3 = new Bird();
Person p = new Person();
p.feed(ani1);
p.feed(ani2);
p.feed(ani3);
}
}
多态:把不同的数据类型进行统一
输出结果:
猫吃鱼
狗吃骨头
鸟吃米
1. 把子类的对象赋值给父类的对象 -> 向上对象
缺点:会屏蔽掉子类中特有的方法
2. 把父类的对象转化回子类的对象 -> 向下转型
向下转型有可能有风险,java要求必须要写强制类型转换
(转换后的数据类型)变量
//向下转型 Cat cc = (Cat) ani1; cc.catchMouse(); ((Cat) ani1).catchMouse(); // ani1.catchMouse(); 报错
7. final关键字
1. 被 final 修饰的变量不可以被改变
2. 被 final 修饰的方法不可以被重写
3. 被 final 修饰的类不可以被继承
8. 抽象类
抽象:只声明,不实现。
public abstract class Animal { //类中有抽象方法,那么这个类是一个抽象类
// abstract修饰方法,这个方法就是一个抽象方法,抽象方法没有方法体
public abstract void eat();
}
1. 抽象类不可以创建对象
2. 抽象类的子类,必须重写父类的抽象方法
通过抽象类可以强制地要求子类中必须有哪些方法。
注:抽象类中可以有正常的方法。
9.接口
接口实际上是一种特殊的抽象类。
接口中所有的方法都是抽象方法。
接口中所有变量都是全局静态变量(public static final)。
接口使用 interface 来声明。
// 能继承接口的只能是接口
// 接口和类只能是实现关系 implements
public interface Valuable {
// 接口中所有的方法都是抽象方法,可以省略掉abstract
//接口中所有内容都是公开的,公共的
void getMoney() ; // 接口中所有的方法都是抽象方法,不可以有正常方法
}
// Valuable.java
public interface Valuable {
void getMoney();
}
// Gold.java
public class Gold implements Valuable {
// 必须 实现 抽象方法
public void getMoney(){
System.out.println("实现");
}
}
// Test.java
public class Test {
public static void main(String[] args) {
Gold g = new Gold();
g.getMoney();
}
}
1. 类只能单继承,接口支持多实现。即类只能继承一个类,但可以实现多个接口。
2. 接口同样具有多态性。
3. 接口可以把很多不相关的内容整合。
快捷方式:
右键 -> generate -> override -> 选中要重写的方法
10. 成员变量初始化
待补充……