Java入门到超神05
JAVA 05
-
Oop面向对象编程
-
oo面向对象
-
面向对象&面向过程
-
- 物以类聚（分类、对某个分类进行独立的思考->框架
-
2.步骤清晰简
-
面向对象本质：类的方式组织代码，对象的方式组织（封装）数据;
-
抽象->xiang
-
三大特性
- 封装
- 继承
- 多态
-
认识的角度现有对象然后又类，类是抽象的，是对对象的抽象
-
代码运行的角度是先有类再有对象，对象是类的模板
方法
import java.io.IOException;
//类
public class Demo01 {
//main方法
public static void main(String[] args) {
new Demo01().lov();
}
/*
修饰符 返回值 方法名（参数）
//方法体
return 返回值
*/
public String sayHello(){
return "heoo";
}
public void lov(){
System.out.println("I love you kdd");
return;
}
public int max(int a,int b){
int c;
return a>b?a:b;
}
/*
brak switch 结束循环 return 结束方法返回结果
*/
public void readFile(String file)throws IOException{
}
}
//导入的是包;
//学士类
public class Student {
//方法
//类实例化之后才会存在
public void say(){
System.out.println("学生说话了");
}
//和类一起加载的
public static void a(){
//say();
}
}
public class Demo02 {
//静态方法 static
//非静态方法
public static void main(String[] args) {
new Student().say();
}
}
值传递
//值传递
public class Demo04 {
public static void main(String[] args) {
int a=1;
Demo04.change(a);
System.out.println(a);
}
public static void change(int a){
a=10;
}
}
//引用传递 对象 本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
Person person1 = new Person();
System.out.println(person.name);
person.name="康丹丹";
System.out.println(person.name);
System.out.println(person1.name);
}
}
//定义一个Person类 一个属性 name
class Person{
String name;//null;
}
对象
- 共同特征的事务抽象的（类
- 具体的实例（对象
- New关键字创建对象
//一个项目只有一个main方法
public class Application {
//类抽象实例化对象
public static void main(String[] args) {
//student是Studdent的对象
Student student = new Student();
}
//对世界更好的建模 音乐
}
//面向对象 类的方式组织代码，对象的方式封装数据
package com.kangsdan.Base.OOp;
//学士类
public class Student {
//属性
String name;
//方法
//类实例化之后才会存在
public void say(){
System.out.println("学生说话了");
}
//和类一起加载的
public static void a(){
//say();
}
}
构造器
- 构造方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y0Lup9dy-1591358572412)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200531110907332.png)]
1.必须与类名相同 类型为空
public class Person {
//一个类上面都没有也会存在方法
//显示定义的构造器
//实例化创建
//使用new关键字必须有构造器，本质就是调用构造器
public Person(){
System.out.println("hello");
}
//创建了有参构造必须有无参
public Person(String name){//重载
}
//alt+ins快捷键
}
构造器
- 相同
- 无返回
- 初始
- new 本质就是调用构造器方法
- 想使用有参必须显式定义一个无参构造
- this.当前类的东西
内存的简单分析
常量直接在栈里面
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-21bEK0HW-1591358572413)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200603171848614.png)]
/**
* 类是一个模板 对象是具体的实例
* 类是抽象的 对象是具体
* 定义 与调用
* 引用类型 除基本类型都是影响，对象是通过是引用操作的
* 对象是通过是引用来操作的 栈-》堆中
* 对象属性 -》字段 成员变量 属性和
* 属性会有默认的初始化
* 数值 0 0.0
* char u0000
* boolea false
* 引用null
* 基本类型 8；
* 修饰符 类型 属性名 值
* 方法
*
* 对象的创建和使用
* 必须用new
* 构造器
* 对象的属性 Person per =new Person(); per.name; per.sleep();
* 类是
* 静态的属性 操作
* 动态的属性 方法
** **封装 继承 多态
*/
封装
-
高聚合 低耦合（内部细节是自己完成的，不允许外部干涉，低耦合 ：仅暴露少量的方法给外部使用
- 电视机 提供接口
-
禁止访问对象中的实际数据 应该通过接口来访问
-
私有属性 get set
public class T1 {
//私有属性
private String name;
private int id;
private char sex;
//获得属性（字段
public String getName() {
return name;
}
//设置属性 （字段
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
public class Appliction {
static int[] a=new int[10];
public static void main(String[] args) {
//实例化对象
T1 t1 = new T1();
t1.setName("康丹");
System.out.println(t1.getName());
}
}
- 通过get和set 就可以保证安全
- 保护数据，隐藏代码的细节
- 统一接口
- 提高了系统的维护性
重载（复习
实现；
//方法 参数都相同都是方法
继承
- 继承是对一批类的抽象 ，实现 父类的扩展
- extends 扩展 ，子类是父类的扩展
- java中只有单继承 没有多继承（一个儿子只有一个爸爸，一个爸爸几个儿子
- 继承是类和类之间的一种关系 （还有组合 聚合 依赖
- 子类 派生类 父类 基类 extends
- is a的关系
package com.kangsdan.Base.Exten;
//这是一个类 人
//public
//protected
//default
//private
public class Person {
public int mon=1000_121;
public void say(){
System.out.println("说了一句话");
}
//ctrl+h可以显示继承表
}
package com.kangsdan.Base.Exten;
public class Student extends Person{
//子类继承了父类就有他的全部方法
//123_444
}
package com.kangsdan.Base.Exten;
public class Appliction {
public static void main(String[] args) {
new Student().say();
}
}
package com.kangsdan.Base.Exten;
//学生是人 派生类
public class Teacher extends Person{
}
- object类
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qyvK1PNa-1591358572416)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200531151158617.png)]
在java中默认继承object
- 贯穿java
super
package com.kangsdan.Base.Exten;
public class Student extends Person{
//子类继承了父类就有他的全部方法
//123_444
private String name="老赵";
public void test(String name){//kd
System.out.println(name);//kd
System.out.println(this.name);//老赵
System.out.println(super.name);//进
}
}
//没有关键字调用本方法
//this调用 类方法
//super继承 父类
package com.kangsdan.Base.Exten;
//这是一个类 人
//public
//protected
//default
//private
public class Person {
protected String name="进";
public int mon=1000_121;
public void say(){
System.out.println("说了一句话");
}
//ctrl+h可以显示继承表
}
package com.kangsdan.Base.Exten;
public class Appliction {
public static void main(String[] args) {
Student person = new Student();
person.test("kd");
}
}
//私有的属性没办法继承
public class Person {
public Person(){
System.out.println("Person");
}
}
package com.kangsdan.Base.Exten;
public class Student extends Person{
//子类继承了父类就有他的全部方法
//123_444
public Student(){
super();//有产必须有参
System.out.println("student");
}
}
package com.kangsdan.Base.Exten;
public class Appliction {
public static void main(String[] args) {
Student person = new Student();
//Person
//student
//默认就吊用了父类的构造方法 调用父类的构造器必须在子类的第一行
}
}
-
super 调用夫类的构造方法必须在第一个
-
super 必须在子类的构造方法 或者方法中 否则就是object的
-
super和this不能同时调用构造方法
-
this代表本身 super 调用父类
-
this 上面时候都可以
-
super 继承
-
this（）本类的构造
-
父类的构造
- 方法
方法的重写–>多态
- 重写只和静态方法有管，和非静态方法无关
public class Demo02 {
public void test(){//static的方法是没有办法重写的
System.out.println("B");
}
}
public class Demo01 extends Demo02{
@Override
public void test() {
super.test();
}
}
public class Appliction {
//方法的调用与定义的类型有关
public static void main(String[] args) {
new Demo01().test();//走Demo01
Demo02 demo02 = new Demo01();
//父类指向了子类 static的方法才是这样的本身static不是继承
demo02.test();//走Demo02
}
}
总结
- 重写：需要有继承关系 。子写夫
- 方法 参数列表 必须相同
- 可以放大 博客与缩小 修饰符
- public》protected》default 》private
- 异常范围可以缩小不可以扩大
- ClassNotFound–>Exception
- 方法相同，方法体不同
为什么需要重写
父类的功能 子类不一定需要