Java类及类的成员:属性,方法,构造器,代码块,内部类
面向对象的三大特征:封装性,继承性,多态性,(抽象性)
其他关键字:this , super , static ,final ,abstrcat , interface , package ,import
面向对象程序设计的重点是类的设计
设计类即设计类成员
什么是类?
类是对一类事物的描述,抽象的概念上的定义
怎么创建一个类?
什么是对象?
实际存在的该类事物的每个个体(实例)
怎么创建一个对象?
怎么使用一个对象?
*属性:对应类中的成员变量
*行为:对应类中的成员方法即函数
类和对象的使用
package object;
public class object1 {
public static void main(String[] args) {
//创建Person类的对象即实例化
Person p1=new Person();
//调用对象的结构:属性,方法
//调用属性:对象.属性;
p1.name="Tom";
p1.isMale=true;
System.out.println(p1.name);
//调用方法:对象.方法;
p1.eat();
p1.sleep();
p1.talk("Chinese");
}
}
//创建Person类
class Person{
//属性
String name;
int age=1;
boolean isMale;
//方法
public void eat() {
System.out.println("人吃饭");
}
public void sleep() {
System.out.println("人睡觉");
}
public void talk(String language) {//有参
System.out.println("人说话,使用的是:"+language);
}
}
1 封装性的理解:
创建一个类的对象后,可通过对象.属性对对象的属性进行赋值,此时赋值操作要受属性的数据类型和存储范围制约,but需给属性赋值加入额外的限制条件,条件不能在属性声明时体现,只能通过方法进行限制条件的添加(如setName())
同时避免用对象.属性对属性赋值,需将属性声明为私有的private。
将类的属性xxx私有化(private),同时提供公共的(public)方法来获取getXxx和设置setXxx此属性的值
1 复杂性封装,对外提供简单的操作入口。
2 private 修饰的数据只能在本类中访问
/*set方法的命名规范
* public void setAge(int a){
* age=a;
* }
* get方法的命名规范
* public int getAge(){
* return age;
* }
* setter and getter方法没有static关键字
* 有关键字static关键字修饰符方法怎么调用:类名.方法名(实参);
* 没有static关键字如何调用:引用.方法名(实参);
*/
package object;
public class object2 {
public static void main(String[] args) {
Person1 p1=new Person1();
Person1 p2=new Person1("胡大爷",78,"男","广场舞领舞的");
System.out.println(p1.getName());
System.out.println(p2.getName());
p1.setName("胡图图");
System.out.println(p1.getName());
}
}//类的封装性
class Person1{
private String name;
private int age;
private String gender;
private String work;
public Person1() {//无参的构造方法
}
public Person1(String name,int age,String gender,String work ) {//有参的构造方法
this.name=name;
this.age=age;
this.gender=gender;
this.work=work;
}
//设置方法
public void setGender(String gender) {
this.gender=gender;
}
//获取方法(有返回值)
public String getGender() {
return this.gender;
}
//shift Alt S
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;
}
public String getWork() {
return work;
}
public void setWork(String work) {
this.work = work;
}
}
2 继承性
格式:class A extends B{ }
A:子类,派生类,subclass
B:父类,超类,基类,superclass
体现:A继承B后,A获取了B中声明的所有属性和方法
父类中声明为private的属性或方法,子类继承父类以后,仍然获取了父类中私有的结构
因为封装性,使子类不能直接调用父类的结构
package object;
public class object3 {
public static void main(String[] args) {
Student s=new Student();
s.talk();
s.sleep();
System.out.println(s.getName());
s.setName("胡大爷");
System.out.println(s.getName());
}
}
class Person2{
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name=name;
}public void sleep() {
System.out.println("父类中的sleep()");
}
private void eat() {
System.out.println("父类中的eat()");
}
protected void talk() {
System.out.println("父类中的talk()");
}
}
class Student extends Person2{
public void sleep() {
System.out.println("小学生库里要睡午觉");
}
}
3 多态性
- 一个事物多种形态
- 特点:多态性形式的对象(Person3 p1 = new Man();)
- 此对象只能调用父类中声明过的方法或者子类中重写过得方法
- 规律:调用方法时,先看右边再看左边
- 创建方式:通过子类的构造方法创建一个父类的对象
package object;
public class object4 {
public static void main(String[] args) {
Person4 p1=new Person4();
p1.eat();
Man man=new Man();
man.eat();
man.age=25;
man.earnMoney();
//***********************************************8
//对象的多态性:父类的引用指向子类的对象(子类的对象赋给父类的引用)
Person4 p2=new Man();//编译看左,运行看右
//Person4 p3=new Woman();
//多态的使用:当调用子父类同名同参的方法时,实际执行的是子类重写父类的方法---虚拟方法调用
//多态的前提条件1 类的继承2 方法的重写
p2.eat();
p2.walk();
}
}
class Person4{
String name;
int age;
public void eat() {
System.out.println("人吃饭");
}
public void walk() {
System.out.println("人走路");
}
}
class Man extends Person4{
boolean isSmoking;
public void earnMoney() {
System.out.println("男人挣钱");
}
//重写方法
public void eat() {
System.out.println("男人多吃饭");
}
public void walk() {
System.out.println("走路拽");
}
class Woman extends Person4{
boolean isBeauty;
public void goShopping() {
System.out.println("女人购物");
}
//重写方法
public void eat() {
System.out.println("仙女不吃饭");
}
public void walk() {
System.out.println("扭扭");
}
}}
4 接口的实现
package foryou.classTest;
//定义接口
interface Person4{
public static final int MAX = 100;
int a = 10;
public abstract void eat(); //修饰词: public abstract(默认)
public void special();
public void sleep();
public static void speak() { //静态方法
System.out.println("英文");
}
public default void speak2() { //静态方法
System.out.println("英文");
}
}
class Man2 implements Person4{
public void eat() {
}
public void special() {
}
public void sleep() {
}
}
class Woman2 implements Person4{
public void eat() {
}
public void special() {
}
public void sleep() {
}
}
public class Dome4 {
public static void main(String[] args) {
Man2 m = new Man2();
}
}
构造器
/*构造方法又称构造器Constructor
* 构造方法语法结构
* 【修饰符列表】构造方法名(形式参数列表){
* 构造方法体;
* }
* 构造方法名必须与类名保持一致。
* 构造方法的作用:
* 通过构造方法的调用可以创建对象。
* 构造方法如何调用?
* new 构造方法名(实参列表);
*/