修饰符 class 类名{
//类中的五大成分。
1.成员变量（属性）
2.成员方法 (行为)
3.构造器 （初始化类的对象数据的）
4.内部类
5.代码块
}
1.1.2 演示类的定义
public class Student {
//成员变量
String name;
int age;
//成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
//无参构造(初始化类的对象数据的)
public Student() {
}
//满参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//内部类
public class Inner{
}
// 5.代码块
{
System.out.println("我是代码块");
}
}
封装---面向对象的三大基本特征
1.2.1 封装的概念
封装可以被认为是一个保护屏障，对外隐藏具体的实现细节，防止该类的代码和数据被其他类随意访问。
ps: 对外可以被访问的数据，通过提供指定的数据访问接口，供其他类调用。
因此封装有两个方面的含义：
- 就是把该隐藏的隐藏——实现对对象内部信息的隐藏和保护。
- 把该暴露的暴露——实现与其它对象和外部程序的交互。
属性的封装只是封装的一种表现形式，方法、类等都时封装的表现形式。
属性的封装：
-
使用private关键字来修饰成员变量。
-
使用public修饰getter和setter方法。
public class Student {
//私有化修饰成员变量
private String name;
private int age;
//提供公共的访问方式(获取，修改)
public String getName(){
return name;
}
public void setName(String n){
name=n;
}
public int getAge(){
return age;
}
public void setAge(int a){
age=a;
}
}
构造方法
1.3.1 构造方法的作用
-
通过调用构造器可以返回一个类的对象
-
构造器可以帮我们把对象的数据（属性和行为等信息）初始化好。
修饰符 类名(形参列表) {
// 构造体代码，执行代码
}
1.3.3 演示构造方法定义
public class Student {
//私有化修饰成员变量
private String name;
private int age;
//无参构造
public Student(){
}
//有参构造
public Student(String n){
name=n;
}
public Student(int a){
age=a;
}
//满参构造
public Student(String n,int a){
name=n;
age=a;
}
}
如何通过类创建对象
1.4.1 对象创建格式
类名 对象名称 = new 类名(形参);
1.4.2 演示创建对象public class Test {
public static void main(String[] args) {
//无参构造
Student s1 = new Student();
s1.show();
//有参构造
Student s2 = new Student("张三");
s2.show();
Student s3 = new Student(18);
s3.show();
//满参构造
Student s4 = new Student("张三",18);
s4.show();
}
}
//学生类代码
public class Student {
//私有化修饰成员变量
private String name;
private int age;
//无参构造
public Student(){
}
//有参构造
public Student(String n){
name=n;
}
public Student(int a){
age=a;
}
//满参构造
public Student(String n,int a){
name=n;
age=a;
}
//提供公共的访问方式(获取，修改)
public String getName(){
return name;
}
public void setName(String n){
name=n;
}
public int getAge(){
return age;
}
public void setAge(int a){
age=a;
}
//展示成员内容
public void show(){
System.out.println(name+"----"+age);
}
}
this关键字的作用
1.5.1 this关键字的作用
this代表所在类的当前对象的引用（地址值），即代表当前对象。用来区分同名的成员变量和局部变量--说人话就是谁在调用这个方法,这个this就是谁/或者说全局变量是谁就是谁
1.5.2 this关键字的常见应用-
用于普通的gettter与setter方法
this出现在实例方法中，谁(哪个对象)调用这个方法，this就代表谁(哪个对象)。
根据就近原则默认指向成员变量的调用，默认隐含this,this可以不写。
-
用于构造方法
this出现在构造器中，代表构造器正在初始化的那个对象
//学生类代码
public class Student {
private String name;
private int age;
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
继承
2.1.1 继承的引入
理解1：生活中的继承关系
理解2：编程中的继承关系
分析下面两个类存在的继承关系
-
学生类（Student） 属性:姓名,年龄 行为:吃饭,睡觉
-
老师类（Teacher） 属性:姓名,年龄，薪水 行为:吃饭,睡觉，教书
结论：向上抽取，向下实现
-
假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到一个单独定义的类中。
-
多个类无需再定义这些共有属性和行为，只要继承那一个类即可。
-
继承后，多个类中特有的属性和方法可以在自己的类中实现。
-
建立继承关系后，多个类可以称为子类，单独定义的类称为父类、超类（superclass）或者基类。
继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。
子类可以直接访问父类中的非私有的属性和行为。
继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。
父类更通用，子类更具体。通过继承，可以使多种事物之间形成一种关系体系。例如，兔子属于食草动物，食草动物属于动物。
2.1.3 继承的好处-
提高代码的复用性
-
使类与类之间产生了关系。
-
多态的前提。
通过 extends 关键字，可以声明一个子类继承一个父类
class 父类 {
...
}
class 子类 extends 父类 {
...
}
2.2.2演示继承定义
//父类代码
public class Person {
String name;
int age;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
//子类代码
public class Student extends Person {
}
//Teacher子类
public class Teacher extends Person {
int salary;
public void teach() {
System.out.println("讲javaEE");
}
}
//测试类
public static void main(String[] args) {
//创建Student对象，并使用
Student s = new Student();
System.out.println(s.name+"---"+s.age);
s.name="张三";
s.age=18;
System.out.println(s.name+"---"+s.age);
s.eat();
s.sleep();
System.out.println("---------");
//创建Teacher对象，并使用
Teacher t =new Teacher();
System.out.println(t.name+"---"+t.age);
t.name="jlf";
t.age=30;
System.out.println(t.name+"---"+t.age);
t.eat();
t.sleep();
t.teach();
}
}
