3_Java初级学习

于 2023-12-20 12:03:41 发布
阅读量1k 收藏 17
点赞数 24
分类专栏： java 文章标签： java 学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74220163/article/details/135104802
版权

Java基础阶段_3

OO：面向对象
OOA：面向对象的分析
OOD：面向对象的设计
OOAD：面向对象的分析与设计(OOA与OOD的组合)
OOP：面向对象的编程

//搞懂什么是：变量，方法，类
//变量
int a;
//方法
public static void 方法名() {  //public static 修饰词和关键字
    // 方法体
}
void 方法名() {  
    // 方法体
}
//类//学生类
public class Student {}

学习的关键字：this，super，extends， static，final，static final，abstract，interface，enum

  1. this：
    this.成员变量名--------------------------this只能用在方法中，方法中访问成员变量之前默认有个this
    this.方法名()-------------------------------调用方法
    this()-----------------------------------------调用构造方法

  2. super：子类用
    编译器：默认提供一个无参构造方法，自己写了构造方法，编译器不再提供
    子类继承父类时默认调用无参构造，在子类中自己调用了父类中的构造方法，编译器不再提供

    super.成员变量名-----------------------访问父类的成员变量
    super.方法名()----------------------------调用父类的方法
    super()--------------------------------------调用父类的构造方法

    
class 父类{
    父类(){
      
    }
}
class 子类 extends 父类{
   super()//这句话默认不写也有
}//

  3. extends
    一个子类只能继承一个父类

    //继承
class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}//

继承+重写
class 父类{
    void 重写(){
      语句块
    }
}
class 子类 extends 父类{
      void 重写(){
      语句块
    }
}

  4. static：静态块类被加载时自动调用，存在于方法区中只调用一次，new对象时：先走静态块，再走构造方法

实例变量需要对象点

静态方法中没有对象，意味着不能直接访问实例变量，就是没有this隐式传递，通过类名点来访问

//静态变量
static int b;//类名.---------------访问
//静态方法
static void test(){}//类名.---------------访问
//静态块
static{
System.out.println("静态块");
}

以后遇见先new对象再点方法的是实列方法，类名直接点的是静态方法
Math:数学工具类，里面封装了很多数学相关的静态方法/工具
Arrays:数组工具类，里面封装了很多数组相关的静态方法/工具

  1. . final：
    最终的、不可改变的
    修饰变量：变量不能被改变
    修饰方法：方法不能被重写
    修饰类：类不能被继承

    final int a = 5;
final void show(){ }
final class Doo{}

  2. static final常量
    必须声明同时初始化
    常常通过类名点来访问，不能被改变

    public static final int COUNT = 5; //常量

  3. abstract 抽象方法，有抽象方法的一定是抽象类
    抽象类一定是被继承的，继承必须重写父类中所有抽象方法

    public abstract class Student {
  abstract void study1();
  abstract void study2();
  abstract void study3();
}

  4. interface项目经常用 继承是单一继承，接口可以实现多个,
    既想继承又想实现时，应先继承，后实现

    interface Aoo{
  void study1();
  void study2();
}
interface Boo{
  void study3();
  void study4();
}
class Coo implements Aoo,Boo{
  public void study1(){}
  public void study2(){}
  public void study3(){}
  public void study4(){}
}

    类和类-------------------------------继承 单一
    接口和接口-------------------------继承 单一
    类和接口----------------------------实现     ** 多个**

  5. 向上造型，用的时候再了解也行

    interface 学生{
  void 学习();
}
interface 老公{
  void 挣钱();
}
class 你 implements 学生,老公{
  public void 学习(){}
  public void 挣钱(){}

}
//造型造型，你是什么类，只能用什么方法
学生 A1 = new 你，作为学生你只能调用学习
老公 A1 = new 你，作为老公你只能调用挣钱
------------------------------------------------------------------

class Aoo{ //父类
   void 父类() {
     System.out.println("动物");
   }
	}

class Boo extends Aoo{ //子类
  void show() {
    System.out.println("小猫");
  }
	}
}
class Coo extends Aoo{ //子类
  void show() {
    System.out.println("小狗");
  }
	}
}
Aoo o1 = new Boo();//只能使用父类方法o1.但是类型相同了
Aoo o2 = new Coo();//只能使用父类方法

//向下造型/强制类型转换
Boo o3 = (Boo)o1;
Coo o3 = (Coo)o1;

  6. 内部类

    class A{
  class B{//这就是内部类
    
  }
}
------------------------------------------------------------------
//匿名内部类
public class Aoo {
public static void main(String[] args) {
  Boo b = new Boo(){};//匿名内部类
}}
abstract class Boo{
  
}

  7. get 和 set方法：变量私有只有自己能直接访问，记住怎么写，多练，快捷生成：Alt+Insert----->Getter+Setter选所有参数

    public class get和set方法 {
    private String name;
    private int age;

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }
}

  8. 枚举
    values，valueOf

    public enum 季节枚举{
  AAA,BBB,CCC,DDD;
}//这样不会报错，类名.lie
----------------------------------------------------
public enum 季节 {
    AAA("",""),
    BBB("",""),
    CCC("",""),
    DDD("","");

    季节(String 季节, String 感觉) {
        this.季节 = 季节;
        this.感觉 = 感觉;
    }//有构造方法，枚举就得有参数，别忘了写get和set方法
==========================================================
完整的如下：
package java基础;

public enum 季节 {
    AAA("",""),//列如：AAA("春天","舒服")
    BBB("",""),
    CCC("",""),
    DDD("","");

    季节(String 季节, String 感觉) {
        this.季节 = 季节;
        this.感觉 = 感觉;
    }

    private String 季节;
    private String 感觉;

    public String get季节() {
        return 季节;
    }

    public void set季节(String 季节) {
        this.季节 = 季节;
    }

    public String get感觉() {
        return 感觉;
    }

    public void set感觉(String 感觉) {
        this.感觉 = 感觉;
    }

}

public class 枚举应用{
  public static void main(String[] args) {
    季节[]  A1 =  季节.values//获取所有枚举对象
    季节  A2 =  季节.AAA//AAA你自己设定的什么季节和感觉
    System.out.println(A2.get季节());
    System.out.println(A2.get感觉());
    
}
  
}

访问控制修饰符:

public：公开的，任何类----------------------------常用
private：私有的，本类------------------------------常用

static：静态的 ,类名点来访问

protected：受保护的，本类、派生类、同包类
默认的：什么也不写，本类、同包类
访问权限由低到高依次为：private<默认的<protected<public

成员变量分为：实例变量和静态变量
实例变量：没有static修饰，属于对象，存储在堆中，有几个对象就有几份，通过对象/引用打
点来访问
静态变量：有static修饰，属于类，存储在方法区中，只有一份，常常通过类名点来访问

内存管理：由JVM来管理的
堆： new出来的对象(包括实例变量、数组的元素)
栈： 局部变量(包括方法的参数)
方法区： .class字节码文件(包括静态变量、所有方法)

  1. 创建类？创建对象？访问类中成员？
    大概看懂就行，一般都用方法的重载

    //创建类就是创建Class文件，具体请看项目的创建
package day01;
//学生类
public class Student {
//成员变量
String name;
int age;
String address;

//方法
void study(){
System.out.println(name+"在学习...");
}

void sayHi(){
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家
住"+address);
}

}


    package day01;
//学生类的测试类
public class StudentTest {
public static void main(String[] args) {
  
//创建学生对象
Student zs = new Student();

//访问成员变量
zs.name = "zhangsan";
zs.age = 24;
zs.address = "河北廊坊";
//调用方法
zs.study();
zs.sayHi();

  2. 方法的重载
    在同一类中，方法名相同，参数列表不同

    package java基础;

public class 学生类 {
    void show(){}
    void show(String name){
        System.out.println(name+"在学习...");
    }
    void show(int age){
        System.out.println("今年"+age);
    }
    void show(String name,int age){
        System.out.println("大家好，我叫"+name+"，今年"+age);
    }
    void show(int age,String name){
        System.out.println("大家好，我叫"+name+"，今年"+age);
    }
}

    package java基础;

public class 学生类使用 {
    public static void main(String[] args) {
        学生类  aa = new 学生类();
        aa.show(32,"小米");//这样调用的是学生类中最后一个方法，剩下的自己尝试调用，
                           //不要用中文，我用中文为了更直观
    }
}

  3. 也可以new对象时传参数：构造方法
    给成员变量赋初始值，与类同名、没有返回值类型(连void都没有)，创建对象时被自动调用
    若是自己不写，则编译器默认提供一个无参构造方法，
    若是自己写了，则不再默认提供
    注：this：指代当前对象，哪个对象调用方法指的就是哪个对象
    super：指代当前对象的超类对象

    package java基础;

public class 学生类 {
  String name; //成员变量
  int age;
  String address;
  
    //构造方法----给成员变量赋初始值
  学生类(String name,int age,String address){ //局部变量
  this.name = name;
  this.age = age; 
  this.address = address; 
  }
  
    void show1(String name){
        System.out.println(name+"在学习...");
    }
    void show2(int age){
        System.out.println("今年"+age);
    }
    void show3(String name,int age){
        System.out.println("大家好，我叫"+name+"，今年"+age);
    }
}//注意方法名不同

    package java基础;

public class 学生类使用 {
    public static void main(String[] args) {
        学生类  aa = new 学生类("小米","19","山东");
        学生类  bb = new 学生类("小琪","22","四川");//类比做公司，方法比作公司的产品，谁用都行
        aa.show1();//不用传参数，new对象时已经传完了
        aa.show2();                   //不要用中文，我用中文为了更直观
    }
}

  4. 内存管理：由JVM来管理的
    堆：new出来的对象(包括成员变量、数组的元素)
    栈：局部变量(包括方法的参数)
    方法区：

  5. Java的继承
    1.代码复用、extends
    父类：共有的属性和行为 ，子类：特有的属性和行为
    子类可以访问子类的+父类的，父类是不能访问子类的
    2.单一继承，传递性

    class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

    class 父类A{
    int age;
    String name; 
    void show(){
    System.out.println("我们都是人");
    }
    void show1(){
    System.out.println("我们都是好人");
    }
}
class 子类A extends 父类A{
    void show2(){
    System.out.println("我们都会Java");
    }
    void show3(){
    System.out.println("我们都是学生");
    }
}


public class 使用 {
	public static void main(String[] args) {
	System.out.println("在学校");
	子类A 子类=new 子类A();     //声明一个Student类的实例对象student
	子类.name="Tom";                //子类调用父类的成员变量name并赋值
	子类.age=19;                    //子类调用父类的成员变量age并赋值
	子类.show();    //子类调用父类的成员方法show
	子类.show2();  //子类调用自己的成员方法show
	}
}
//这里面在学校里我们都是人，没疑问吧，但是学校里有学生类，有老师类，如果在子类中重复强调我是人，
//代码啰嗦，就用到了父类

停留时间
关注
  • 24
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值