类和对象的关系
类就是：对现实生活中事物的描述。
对象：就是这类事物，实实在在存在个体。
属性对应是类中变量，行为对应的类中的函数(方法)。
其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。
在类中定义其实都称之为成员。成员有两种：
1：成员变量：其实对应的就是事物的属性。
2：成员函数：其实对应的就是事物的行为。
class Student {
// 成员变量
String name = "张三"; // 姓名
int age = 24 ; // 年龄
String sex = "男" ; // 性别
// 成员方法
// 学习
public void study(){
System.out.println("学生在学习....");
}
// 吃饭
public void eat(){
System.out.println("学习饿了该吃饭了.....");
}
// 睡觉
public void sleep(){
System.out.println("学习累了,该睡觉了....");
}
}成员变量和局部变量的区别：
1：成员变量直接定义在类中。
局部变量定义在方法中，参数上，语句中。
2：成员变量在这个类中有效。
局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。
3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放
.面向对象(封装的概述)
封装概述:隐藏对象的属性和实现细节，仅对外提供公共访问方式
A:封装好处: 隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
B:封装原则: 将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
4.关键字
Private: 是一个权限修饰符
可以修饰成员变量和成员方法
被其修饰的成员只能在本类中被访问
this : 代表当前对象的引用
Public void setName(String name){
this.name = name;
}
this的应用: 区分成员变量和局部变量重名
static: a:随着类的加载而加载
b:优先于对象存在
c:被类的所有对象共享
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
d:可以通过类名调用,其实它本身也可以通过对象名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
注意事项
a:在静态方法中是没有this关键字的
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
静态方法： 成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
静态只能访问静态。
继承特点：
1，提高了代码的复用性。
2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
java的继承具有单继承的特点，即每个子类只能有一个父类
继承的概念
-
java中不支持多重继承，Java中要求任何的子类只能有一个直系的双亲类
-
可以在子类中进行覆盖定义父类中的成员方法和成员属性
-
Java支持多层继承(继承体系)：C继承B，B继承A，就会出现继承体系。Java中的所有类都直接或者间接的集成于java.lang.
- 父类变，子类就必须变 继承破坏了封装，
- 对于父类而言，它的实现细节对与子类来说都是透明的
- 继承是一种强耦合关系
类的关键字是通过exends来实现的其格式为
【访问权限】class子类名exends父类名
public class sheep exends asdbc{
....
.....
}如果没有exends子句，则这个类直接继承Object。但是如果父类名所在指定的类必须是在当前翻译单元中可以访问的类，否则会产生编译错误。
继承成员变量和方法：如果一个类是另一个的子类，则这个类就会拥有父类中部分成员变量和方法。
子类的构造方法
调用父类的构造方法可以显式地在子类构造方法的第一条语句使用super关键字调用父类的构造方法，也可以隐式地调用父类的构造方法，主要有以下几种情况：
①若父类中没有定义构造方法，系统自动为父类添加一个无参的方法体为空的构造方法，那么对父类对象的初始化将采用系统默认的构造函数。也就是说，一般基本类型的实例变量值为0，boolean类型的变量值为false，对象为null。此时，子类可以不显式地调用父类构造方法，则系统创建子类对象时自动调用父类无参构造方法。
②若父类定义了无参构造方法，那么子类构造方法中不显式地调用父类无参构造方法，则系统创建子类对象时自动调用系统为父类添加的无参构造方法。
③若父类中定义的构造方法都是带有参数的，那么子类构造方法中第一条语句必须使用super语句调用父类有参构造方法。
创建一个父类
public class animal{
private String name；
private String color；
private String sex；
public animal(String name,String color, String sex) {
this.color=color;
this.name=name;
this.sex=sex;
public void prtntMsg()
System.out.println("姓名："+name+"，性别："+sex+"，颜色："+color)；
}
}子类调用
public class sheep extends animal{
private String birth;
public sheep(String name,String color,String sex,String birth) {
super(name, color,sex);
this.birth=birth;
}此地方用的this调用
如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢?
●会报错。因为子类默认是调用父类无参构造器的。
public sheep（）{ super（）；//调用父类中无参数的构造方法 }如何解决?
方法1：在父类中添加无参数的构造方法即可。
方法2：在子类构造方法中，通过super（xx）明确调用父类哪一个构造方法。
总结：推荐方法1，定义父类时，要有无参数的构造方法。
执行顺序
顺序如下：
1.父类中静态代码块
2.子类中静态代码块
3.父类中普通代码块
4.父类中的构造方法
5.子类中的普通代码块
5.子类中的构造方法
【覆盖】
方法覆盖一般指的就是方法重写
.使用：
当父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重新编写，这个重新编写的过程称为方法的重写/覆盖
任何解决覆盖？
子类如果想使用父类中被隐藏的成员和被隐藏的成员方法，必须要使用关键字super；
格式为：
super.数据成员
super.成员方法(参数)
举例：在父类 Employee中添加了输出各个属性值的toString()方法。
public String toString(){
return"Employee 类属性：ID="+ID
+", name="+ name +",position="+ position +",salary="+ salary +",EmploymentDate="+EmploymentDate;
}在子类（Manager类）中对该方法进行重写。
public class Manager extends Employee {
private double bonus;
public Manager( String name,String ID, String position,double salary,int year, int month, int day,double bonus){
super(name,ID,position,salary,year,month,day)；//调用父类有参构造方法
this. bonus=bonus;
}
public double getBonus(){
return bonus;
}
public void setBonus(double bonus){
this. bonus = bonus;
}
public String toString(){
；/*调用父类被覆盖的同名方法*/
return"Manager类属性：bonus=”+bonus+“继承自父类”+ super.toString()+“]”；
}
}
super的两种使用情况：
1：访问被子类隐藏的超类的成员变量和成员方法，格式为：
super.数据成员
super.成员方法（参数）
2：虽然构造方法不能够继承，但利用super关键字，子类构造方法中也可以调用父类的构造方法。调用父类的构造函数格式如下：
super（ <参数列表> )
关键字final
1.如果引用为基本数据类型，则该引用为常量，该值无法修改；
如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。
如果引用时类的成员变量，则必须当场赋值，否则编译会报错。
final class Person {
//3. 此处不赋值会报错
String name ="zs";
//final int age;
final int age = 10;
}
public class Demo01 {
public static void main(String[] args) {
//1. 基本数组类型为常量，无法修改
final int i = 9;
//i = 10;
//2. 地址不能修改，但是对象本身的属性可以修改
Person p = new Person();
p.name = "lisi";
final int[] arr = {1,2,3,45};
arr[3] = 999;
//arr = new int[]{1,4,56,78};
}
}2.fnal修饰基本数据类型和引用类型的区别。
fìnal修饰基本数据类型变量时，不能对其重新赋值。但final修饰引用类型的变量保存的是一个对象的引用，是该对象的内存地址。只要保证这个引用所指定的对象地址不改变，就一直引用同一对象，但对象本身的内容却完全可以发生改变。
class student{
private String id ="";
private String name="";
private String sex= "";
private int age=0:
this. id=id;
public student(String id,String name) {
this. name = name;
}
public student(String id,String name,String sex,int age) {
this.id=id;
this. name =name;
this. sex=sex;
this, age = age;
}
String getId(){
return id;
}
void setId( String id){
this.id = id;
}
Sring getName(){
return name;
}
void setName(String name){
this. name = name;
}
public String toString(){
retum(”此学生信息为：学号："+id+”，姓名：”+ name+”，性别："+sex+”，：年龄”+
age)；
}
}
public class studentTest{
public statie void main(String[ ]args){
final student s =new student("01","Jack","male",18)；//final修饰 studeat的一个
对象s，s是一个引用变量
System. out. println(s.toString())；
s.setld("02")；//可以修改对象s的属性
s.setName("Bill")；//可以修改对象s的属性
System. out.println(s.toString())；
s=new student("02","Rose","female",17);//对s重新引用一个对象，不合法
}
}从以上程序中可知，使用final修饰的引用类型变量不能被重新赋值，但是引用变量所引用对象的属性可以改变。
(2)fnal关键字修饰方法
final关键字修饰的方法不能被重写，在使用继承编写类的时候，如果不希望子类重写父类的某个方法，可以使用final关键字修饰该方法。
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
