Java OOP 对象和封装
1、面向对象与面向过程的区别
面向对象：面向对象的核心是封装了属性和方法（行为）的类。如果要实现狗狗喝水，只要输出狗狗喝水就行了，大多数都是使用面向对象来进行编程。
面向过程：面向过程的核心是函数，如果要实现狗狗喝水，用面向过程来实现，就要分析水和狗是怎么来的。
2、怎么使用面向对象来进行编程
第一步：发现类。
比如狗狗，狗狗是宠物，还有品种、类型
第二步：发现类的属性。
狗狗是什么品种、什么类型类型、什么名字
第三部：发现类的方法
狗狗吃饭，玩，睡觉，喝水等方法
面向对象设计的过程是抽象过程，根据业务需求，关注与业务相关的属性和行为，忽略不必要的属性和行为。有现实世界中的“对象”抽象出软件开发中的“对象”。
类主要有属性和行为组成，属性和行为又称为类的成员变量或者成员属性和尘缘方法，统称为类的成员，类的成员还包括构造函数和代码块。
学完java之后，在学这个就会觉得很简单，都是一样的，new对象，调方法，就多了一个关键字this，this表示当前类的对象的引用，作用就是引用本类的属性或者方法，只要是在这个类里面的。还有一个关键字final，final表是常量，被这个关键字声明的变量，就只能赋一次值，而且是在声明的时候就要赋值，不能赋第二次值
public class Dug {
String name = "无名氏"; //昵称，默认值是
int health = 1000; //健康值，默认值是100
int love = 0; //亲密度
final String SEX_MALE = "雄";
final String SEX_FEMALE = "雌";
String sex = SEX_MALE;
String strain = "聪明的拉布拉多犬"; //品种
/**
* 输出狗狗信息
*/
public void print() {
System.out.println("宠物的自白：\n我的名字叫"+this.name+"健康值是"+this.health+"何主任的亲密度是"+this.love+"我是一只"+this.strain+"。");
}
}
//下面是测试类
public class Test {
public static void main(String[] aegs) {
Dug pgn = new Dug();
System.out.println("第一个狗狗的性别是"+pgn.sex+"。");
pgn = new Dug();
pgn.sex = pgn.SEX_FEMALE;
System.out.println("第二个狗狗的性别是"+pgn.sex+"。");
pgn = new Dug();
pgn.sex = pgn.SEX_MALE;
System.out.println("第三个狗狗的性别是"+pgn.sex+"。");
}
}
3、构造方法以及重载
先了解构造方法，构造方法就是没有返回值，方法名就是类名；
重载，重载就是在同一类中，相同的方法名，不同参数又包括不同参数个数和对应下标的类型，一下如下代码：
//创建一个Dog类
public class Dog{
int i;
String name;
//创建构造方法
public Dog(){
}
//下面都是构造方法的重载
public Dog(Stirng name){
this.name = name;
}
public Dog(int i){
this.i = i;
}
public Dog(String naem,int i){
this.name = name;
this.i = i;
}
}
4、static修饰符
static可以用来修饰属性、方法和代码块。static 修饰的变量属于这个类所有，即由这个类创建的所有对象共用同一个static变量。通常把static修饰的属性和方法称为类属性(类变量)和类方法。不使用static 修饰的属性和方法属于单个对象，通常称为实例属性(实例变量)和实例方法。使用static 修饰方法的最常见的例子是我们熟悉的main( )方法。
public class StaticTest {
static int i;
static int m =30;
int j;
int k =25;
static {
i = 10;
System.out.println("i的初始值为："+i);
}
public StaticTest() {
j = 20;
System.out.println("j的初始值为："+j);
}
public static void getNum() {
System.out.println("得到i的值为："+i);
}
public static void main(String[] args) {
StaticTest st = new StaticTest();
System.out.println("i的值为："+StaticTest.i);
st.getNum();
System.out.println("m的值为："+st.m);
System.out.println("k的值为："+st.k);
}
}
5、使用封装优化程序
封装的作用：封装的作用是将代码中的细节全部私有化，不让别人看到，比如女孩子化妆，都是将自己最美的那一面展现出来，吧不需要的对象隐藏。
public class Dog{
private String name;
//下面的get和set方法就是封装
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
继承
1、继承
什么叫继承，就像你继承爸爸或者妈妈的容貌，财产等等东西，这就叫做继承，但是继承的前提条件就是，你必须是他们的儿子或者女儿，反正就是离他们最亲近的人才能够继承到他们的东西。在代码里面怎么实现继承呢，extends关键字：
//狗狗与企鹅的父类
public class Pet {
private String name = "无名氏"; //昵称
private int health = 100; //健康值
private int love = 0; //亲密度
/**
* 无参构造方法
*/
public Pet() {
this.health = 95;
System.out.println("执行宠物的无参构造方法。");
}
/**
* 有参构造方法
* @param name
*/
public Pet(String name) {
this.name = name;
}
/**
* @return昵称
*/
public String getName() {
return name;
}
/**
* @return 健康值
*/
public int getHealth() {
return health;
}
/**
* @param health 指定健康值
*/
public void setHealth(int health) {
this.health = health;
}
/**
* @return亲密度
*/
public int getLove() {
return love;
}
/**
* 输出宠物信息
*/
public void print() {
System.out.println("宠物的自白：\n我的名字叫"+this.name+"，我的健康值是："+this.health+"，我和之人的亲密度是："+this.love+"");
}
}
//狗狗类
public class Dog extends Pet{
private String strain; //品种
/**
* @param name 昵称
* @param strain 品种
*/
public Dog(String name,String strain) {
super(name); //此处不能用this.name = name;
this.strain = strain;
}
/**
* @return 品种
*/
public String getStrain() {
return strain;
}
}
//企鹅类
public class Penguin extends Pet{
private String sex; //性别
/**
* @param name 昵称
* @param sex 性别
*/
public Penguin(String name,String sex) {
super(name); //不能this.name = name;
//如果注释super(name)，他就会默认调用父类的无参构造方法
this.sex = sex;
}
/**
* @return 性别
*/
public String getSex() {
return sex;
}
}
//测试类
public class Test {
public static void main(String[] args) {
//1、创建宠物对象pet输出
Pet pet = new Pet("贝贝");
pet.print();
//2、创建狗狗对象dog并输出信息
Dog dog = new Dog("欧欧","学纳瑞");
dog.print();
//3、创建企鹅对象pgn并输出信息
Penguin pgn = new Penguin("娜娜","Q妹");
pgn.print();
}
}
以上就是狗狗与企鹅都继承与动物类，他们都是动物所以可以继承，而且他们都得相同的地方，把他们相同的特征和行为都集合起来，就可以做问他们的父类，extends语法：public class 类名 extends 父类{}；在这里还出现了一个关键字super，他的作用是对父类对象的引用，跟this差不多但是是对父类的。super必须出现在子类的方法和构造方法中，不能出现在其他的位置，而且super调用父类的构造方法必须放在方法里面的第一行。
super.name;//访问父类属性
super.print();//访问父类方法
super(name);//访问父类构造方法
2、重写和继承关系中的构造方法
1、子类重写父类方法
先了解什么叫重写，重写的特点：在不同类中，相同的方法名，相同的参数，前提是继承关系，重写的方法的访问权限必须大于等于被重写方法的访问权限
public class Pet{
public void print(){
System.out.printIn("我");
}
}
public class Dog extends Pet{
@Overrider
public void print(){
System.out.printIn("你");
}
}
public class Pgn extends Pet{
@Overrider
public void print(){
System.out.printIn("它");
}
}
public static void main(String[] args) {
Pet pet = new Pet();
Dog dog = new Dog();
Pgn pgn = new Pgn();
pet.print();
dog.print();
pgn.print();
}
//输出的结果是我，你，它，子类的重写会覆盖父类被重写的方法
代码中还出现了一个关键字@Overrider他的作用是声明重写
3、抽象类
1、抽象类和抽象方法
abstract修饰符，用来修饰类，使类不能实例化，语法：
public abstract class Pet{
//抽象类里面可以有实例方法和抽象方法，构造方法
public void print(){
}
//抽象方法不能有方法体，而且，继承这个类的子类必须重写这个类的抽象方法，除非他的子类也是抽象类
public abstract void Showe();
public Pet(){
}
}
4、final修饰符
1、final的应用
final修饰的是常量，也可以修饰类，被final修饰的类不能被继承，被final修饰的方法不能被重写，final修饰的变量，不管是全局变量还是成员变量都只能赋值一次。
final和abstract是功能相反的两个关键字，可以对比记忆。abstract可以用来修饰类和方法，不能用来修饰属性和构造方法。final 可以用来修饰类、方法和属性，不能修饰构造方法。
5、访问修饰符的访问级别
| 访问修饰符 | 本类 | 同一个包 | 子类【不同包】 | 其他 |
|---|---|---|---|---|
| public | 能 | 能 | 能 | 能 |
| protected | 能 | 能 | 能 | 否 |
| firendly | 能 | 能 | 否 | 否 |
| private | 能 | 否 | 否 | 否 |
多态
1、多态
定义：一件事物的多种形态
实现方式：重载和重写
重载：在同一类中，相同的方法名，不同参数：个数不同，对应下标类型不一样
重写：在不同类中，前提是继承关系，相同的方法名，相同的参数
普通重写：子类不一定要实现父类的的重写方法
抽象类重写：1、必须位于抽象类中，2、子类必须重写父类的抽象方法，除非子类也是抽象类
继承的存在(继承是多态的基础，没有继承就没有多态)。子类重写父类的方法(多态下调用子类重写后的方法)。父类引用变量指向子类对象(子类到父类的类型转换)。
1、子类到父类的转换(向上转型)
将一个父类的引用指向一个子类对象，称为向上转型(upcasting)，自动进行类型转换。此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。此时通过父类引用变量无法调用子类特有的方法。
2、父类到子类的转换(向下转型)
当向上转型发生后，将无法调用子类特有的方法。但是当需要调用子类特有的方法时，可以通过将父类再转换为子类来实现。将一个指向子类对象的父类引用赋给-一个子类的引用， 称为向下转型.此时必须进行强制类型转换。
2、instrceof运算符
//语法
对象 instrceof 类或接口
该运算符用来判断一个对象是否属于一个类或者实现了一个接口，结果为true或false。在强制类型转换之前通过instanceof运算符检查对象的真实类型，再进行相应的强制类型转换，这样就可以避免类型转换异常，从而提高代码的健壮性。
使用instanceof运算符时，对象的类型必须和instanceof的第二个参数所指定的类或接口在继承树上有上下级关系，否则会出现编译错误。例如，pet instanceof String会出现编译错误。instanceof通常和强制类型转换结合使用。通过该示例可以发现，在进行引用类型转换时，先通过instanceof运算符进行类型判断，再进行相应的强制类型转换，这样可以有效地避免出现类型转换异常。
接口
1、接口的定义
//语法
public interface 接口名{
//里面没有变量，只有静态常量，默认访问符public static final
//里面只能是抽象方法,默认的访问修饰符是public abstract
void 方法名();
}
特点：不能被实例化
作用：约束子类必须拥有某个行为
一个类只能有一个父类，但是它可以有多重行为(接口)。
怎么让子类实现接口：implements 接口名1,接口名2
在继承和接口都存在的时候，extends在前，implements在后，不能实例化。 不能有构造方法
IAP:接口隔离原则：一个类对另一个类的依赖应该建立最小的接口上，与单一职责相似，单一职责----->要求类；接口隔离原则------->要求接口。
1、接口和抽象类的区别
相同点：不能new，约定子类必须实现方法。
不同点：关键字，方法不一样，构造方法和成员变量
2、C#实现接口
流程没区别，语法：子类:父类，接口
属性默认：public static const 不能显示定义
符是public abstract
void 方法名();
}
特点：不能被实例化
作用：约束子类必须拥有某个行为
一个类只能有一个父类，但是它可以有多重行为(接口)。
怎么让子类实现接口：implements 接口名1,接口名2
在继承和接口都存在的时候，extends在前，implements在后，不能实例化。 不能有构造方法
IAP:接口隔离原则：一个类对另一个类的依赖应该建立最小的接口上，与单一职责相似，单一职责----->要求类；接口隔离原则------->要求接口。
##### 1、接口和抽象类的区别
相同点：不能new，约定子类必须实现方法。
不同点：关键字，方法不一样，构造方法和成员变量
##### 2、C#实现接口
流程没区别，语法：子类:父类，接口
属性默认：public static const 不能显示定义
方法：public abstract 不能显示定义
6444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
