1.封装
public class Person {
//特征
private String name;
private int age;
private String gender;
public Person(String name, int age, String gender) {
//this()调用其他的构造方法,需要放在构造方法的第一行
this(name, age);//调用无参数的构造方法
System.out.println("三个参数的构造方法");
//最小作用域最强原则
this.gender = gender;
//没有必要用this调用成员方法,因为重载方法只需要通过实际参数来确定就可以了
// this.setAge(age1);
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(String name) {
super();
this.name = name;
}
//通常情况下会给私有属性提供set/get方法
public Person() {
System.out.println("无参数的构造方法");
}
//set有参数
//get有返回值
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age1) {
if(age1>=0 && age1<150) {
age = age1;
}else {
System.out.println("年龄有误,请重新输入");
}
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
if("男".equals(gender)||"女".equals(gender)) {
this.gender = gender;
}else {
System.out.println("性别有误,请重新输入");
}
this.gender = gender;
}
//行为
public void study() {
System.out.println("学习");
}
public void sleep() {
System.out.println("睡觉");
}
}
public class Test {
public static void main(String[] args) {
//创建对象
Person p = new Person("张三",18,"男");
p.setAge(-8);
System.out.println(" "+p.getAge()+" ");
p.study();
p.sleep();
}
}
2.继承
1.上一辈的东西是可以直接使用的
2.父类的一些私有事务是不能继承的
3.除了继承的以外还可以有自己特有的爱好
优点:1.继承可以减少重复代码,提高代码的复用性
2.java继承增量式的开发
public class Father {
String name;
int age;
private String gender;
public void eat() {
System.out.println("吃");
}
}
public class Son extends Father{
public void classOver() {
System.out.println("下课");
}
}
public class Test {
public static void main(String[] args) {
Son son = new Son();
son.eat();
son.name = "儿子";
son.age = 2;
son.classOver();
}
}
一个子类至多可以继承一个父类
类：单继承
接口：多继承
一个父类可以有多个子类 层次继承
一个子类可以继承一个父类 父类–>父类 层级继承
混合继承–>java继承了父类–>实现了接口–>继承接口
3.super和this关键字的区别
super指代的是父类的对象
super()调用本类的构造方法,创建子类对象的时候调用父类构造方法可以将父类的属性和方法加载到子类的堆内存，子类对象就可以调用父类的属性和方法了
super()如果自己不写，程序会自动的添加，在子类构造方法的第一行
super.属性调用的是父类的属性
super.方法调用父类的方法
this指代的是本类对象
this()调用的是本类的其它构造方法,减少重复代码,提高代码的复用性
this()要放在本类构造方法的第一行
this.属性调用的是本类属性，如果本类没有则调用父类属性，为了解决最小作用域最强原则
this.方法调用的是本类的方法如果本类没有则调用父类的
this和super不能在静态方法或者静态代码块中使用
public class Animal {
String name;
String color;
int age;
public Animal(String name, String color, int age) {
super();
this.name = name;
this.color = color;
this.age = age;
}
public Animal() {
super();
}
public void eat() {
System.out.println("吃");
}
}
public class Dog extends Animal{
//super 父类的对象
public Dog() {
//super()要求放在构造方法的第一行
//super()自动添加
//this()
//this.属性
//this.方法
//super父类对象 super.name super.eat()调用的都是父类的属性和方法
super.name="张三";
super.eat();
System.out.println(this.name);
System.out.println(super.name);
}
public Dog(String name, String color, int age) {
// super(name, color, age);//调用父类的构造方法
}
}
4.重写和重载的区别
重写：
1.继承关系中，子类重写父类的方法
2.返回值类型相同
3.方法名相同
4.参数列表必须和父类相同
5.访问修饰符不能比父类更加严格
6.不能抛出比父类范围广的异常
7.运行时多态的体现
重载：
1.在同一个类中
2.方法名相同
3.参数列表不同
4.返回值没要求
5.访问修饰符没要求
6.抛出异常没有要求
7.编译时多态的体现
public class Transport {
String color;
String brand;
public void run() {
System.out.println("车启动了");
}
}
public class Truck extends Transport{
int load;
@Override
public void run() {
System.out.println("卡车,载重"+load+"货物跑了");
}
}
public class Test {
public static void main(String[] args) {
Truck truck = new Truck();
truck.brand = "沃尔沃";
truck.color = "白色";
truck.load = 30;
System.out.println(truck.brand+" "+truck.color+" "+truck.load);
truck.run();
}
}
5.java中常用的包
package包的关键字，后面跟包名
import导包的关键字 import 包名.类名
一个类想要用其他包中的类都需要导包
包分为两类：1.java提供好的包
java.lang不需要手动导包，java内置了Object String类
java.util工具
java.sql sql相关的包
java.net socket网络
java.io 流
java.awt图形工具包
2.自定义的包
6.4个访问修饰符
1.修饰权限
public 公开的 整个工程，本类本包其他包
protected 受保护的 本类，本包，其他包的子类
缺省 本包
private 私有的 本类
2.可以修饰的地方
类 public 和缺省
属性 4种
方法 4种
7.static修饰符
1.可以修饰属性方法代码块
2.调用方式
类名.属性和方法
对象名.属性和方法
类加载器将类模板加载到了方法区，并且将静态属性方法加载到了静态中
3.静态域中的对属性和方法是供所有对象使用的，是共享的
只要有一个对象进行了修改，所有对象都使用修改以后的值
4.是否所有的属性方法都应该使用静态
(1)使用了静态以后，都是用最后一个修改以后的值，所有人的值都一致
如果所有值都是相同的结果，则可以考虑用静态的，减少内存开销
(2)内存方法静态属性方法比对象存在内存时间都要长，所以适当使用静态
频繁使用的功能可以定义成静态的可以形成工具类
5.静态代码块
{
}
静态代码块无论创建几个对象都只会执行一次
构造代码块会随着独享创建的次数增加而增加
都比构造方法执行的早
局部代码块，是在调用方法的时候才会执行
静态代码块–>构造代码块–>构造方法–>调用的时候才会执行局部代码块
静态代码块:类似于注册数据库的驱动，则可以写到静态代码块中