首页 > 编程语言 >Java学习笔记(十)

Java学习笔记(十)

时间:2023-08-15 15:01:50浏览次数:38  
标签:Java 静态 笔记 class 学习 static println public out

第7章 面向对象(下)

7.1 静态的

1、static:静态的

2、什么是静态的?

和对象无关的,不会因为对象的不同而不同,即所有对象都一样的。

换句话说,和对象无关。


动态的,根据对象的不同而不同,和对象有关,由对象动态决定。


3、static这个关键字用在哪里?

(1)成员变量前面:静态变量

(2)成员方法前面:静态方法

(3)代码块前面:静态代码块

(4)内部类class前面(后面和内部类一起讲):静态内部类

(5)在import语句里面:静态导入

7.1.1 静态变量

4、静态变量

(1)静态变量的定义:是指有static修饰的成员变量

(2)静态变量的特点:

A:静态变量的值是所有对象共享的。

B:虽然可以,但不建议通过“对象.静态变量”的形式进行访问,

建议通过“类名.静态变量”的形式进行访问。

C:如果静态变量的可见性范围被限制了,提供get/set时,它的get/set也是静态的。

在set方法中,静态变量和局部变量(形参)重名了,使用“类名.静态变量”进行区分。

D:静态变量的值是存储在“方法区”中。

//Company公司
public class Employee {
    public static String company;//静态变量
    public String name;//实例变量
    private static String corporation;

    public static String getCorporation() {
        return corporation;
    }

    public static void setCorporation(String corporation) {
        Employee.corporation = corporation;
        //不能使用this.
    }
}
public class TestStaticVariable {
    public static void main(String[] args) {
        Employee e1 = new Employee();
        Employee e2 = new Employee();
        e1.company = "执影";

        System.out.println(e1.company);
        System.out.println(e2.company);
//        System.out.println(Employee.company);

        e2.company = "zhiying";

        System.out.println(e1.company);
        System.out.println(e2.company);

        System.out.println("-----------------");
        //静态变量推荐使用“类名.静态变量”的形式进行访问。
        Employee.company = "执影人";
        System.out.println(Employee.company);
    }
}

7.1.2 静态方法

5、静态方法

(1)静态方法的定义:是指有static修饰的方法。

(2)静态方法的特点:

A:静态方法中不允许直接使用本类的非静态成员

B:静态方法中也不允许直接使用this,super等关键字

C:静态方法的调用虽然可以用“对象.静态方法”的形式进行访问,

但是我们更推荐“类名.静态方法”的形式进行访问。

D:父类的静态方法可以被子类访问,但是不能被子类重写

public class Student {
    private static String school;
    private String name;
    public static String getSchool(){
        return school;
    }
    
    public static void method(){
        System.out.println(this.name);//错误,静态方法中不允许出现this
        System.out.println(name);//错误,静态方法中不允许直接访问非静态的实例变量name
        System.out.println(super.hashCode());//错误,静态方法也不允许出现super
    }
}
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Math.random());

        Student stu = new Student();
        System.out.println(stu.getSchool());
        //编译器也会处理成Student.getSchool()
        System.out.println(Student.getSchool());
    }
}

Java学习笔记(十)_静态变量

public class Father {
    public static void method(){
        System.out.println("Father.method");
    }
}
/*
@Override:是一个注解。
作用:和编译器说,它标记的方法是子类重写父类的方法。请“严格”按照重写的要求进行格式检查。
如果违反重写的要求,就编译报错。

如果一个方法遵守重写的要求,加或不加@Override都可以。
如果一个方法没有遵守重写的要求,不加@Override有可能编译器不提示你错误,导致和你的意图不一致。

 建议:凡是重写的方法,不管你写的对不对,都加@Override。

 */
public class Son extends Father {

    //自己以为我重写成功了,但是其实是不对的
   /* public static void method(){
        System.out.println("Son.method");
    }*/
}
public class TestSon {
    public static void main(String[] args) {
        Father f = new Son();
        f.method();//完全等价于Father.method

        Father.method();
        Son.method();
    }
}

Java学习笔记(十)_System_02

7.1.3 静态代码块

6、静态代码块

(1)静态代码块的作用:为类的静态变量初始化

(2)静态代码块的执行特点

A:一个类的静态代码块只会执行一次

B:它是在类加载类初始化时执行,先于类对象的创建

(3)语法结构

【修饰符】 class 类名{

   static{

       静态代码块

   }

}

public class Demo {
    static {
        System.out.println("静态代码块");
    }

    public Demo(){
        System.out.println("Demo无参构造");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
    }
}

7.1.4 类初始化

7、类初始化

(1)类初始化:为类的静态变量赋值的过程

(2)类初始化相关代码

A:静态变量声明时,直接=值

B:静态代码块


(3)如果我们编写了类初始化相关代码,那么编译器会给我们

把这些代码按照编写顺序组装到一个<clinit>()的类初始化方法中。

cl:class

init:initialize


(4)一定是先完成类初始化,再进行实例初始化(创建对象),

并且一定是先完成父类初始化,再完成子类初始化。

public class SubDemo extends Demo {
    static {
        System.out.println("子类SubDemo的静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        /*Demo d1 = new Demo();
        Demo d2 = new Demo();
*/
        SubDemo s1 = new SubDemo();
        SubDemo s2 = new SubDemo();
    }
}

7.1.5 静态导入

8、静态导入

(1)静态导入的定义:在import语句里面出现static,就是静态导入

(2)作用:在当前的.java文件中,使用另一个类的静态成员时,可以直接在代码中使用静态成员名,而不用“类名.静态成员名。

import static java.lang.Math.*;

public class TestStaticImport {
    public static void main(String[] args) {
        /*System.out.println(Math.PI);
        System.out.println(Math.random());
        System.out.println(Math.sqrt(9));*/

        System.out.println(PI);
        System.out.println(random());
        System.out.println(sqrt(9));
    }
}

7.2 抽象类和抽象方法

1、什么是抽象类?

在class前面加abstract修饰的都是抽象类。


【其他修饰符】 abstract class 类名{


}


2、为什么要用抽象类?

(1)不希望你创建这个类的对象,希望你创建它子类的对象(少一点)

(2)当我们在声明某个父类时,其中某些方法不得不声明,但是又无法给出具体的实现,

即无法编写方法体代码,这个方法体代码通常由子类来实现,各个子类的实现不同,

这个时候需要把这样的方法声明为抽象方法,

Java中包含抽象方法的类必须是抽象类(更多的情况)。


3、抽象类的特点

(1)抽象类不能直接new对象,只能new它子类的对象

(2)抽象类中可以包含抽象方法,也可以不包含抽象方法。

但是反过来,包含抽象方法的类,必须是抽象类。

(3)抽象类是用来被继承的,子类继承抽象类时,必须重写抽象类的所有抽象方法,

否则子类也得是抽象类。


4、抽象类和非抽象类有什么区别?

抽象类不能直接new对象,非抽象类可以直接new对象,

抽象类中可以包含抽象方法,非抽象类中不可以包含抽象方法。


5、抽象类中有构造器吗?

一定有

它的构造器存在的意义是被子类调用的。

public abstract class Person {
    private String name;
    private int age;

    public Person(){
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Student extends Person {
    //....
}
public class Teacher extends Person {
    //.....
}
public class TestPerson {
    public static void main(String[] args) {
        //做学生信息管理系统
        //在整个系统中,要么存在的是学生对象,要么存在的是教师对象
        //希望整个程序中不能直接new Person的对象。
        Person[] arr = new Person[3];
//        arr[0] = new Person();//报错,因为抽象类不允许直接new对象
        arr[1] = new Student();
        arr[2] = new Teacher();
    }
}
//包含抽象方法的类必须是抽象类
public abstract class Graphic {
    /*public double area(){
        return 0.0;
    }*/

    //抽象方法,没有方法体,有abstract修饰
    public abstract double area();
}
public  class Circle extends Graphic {
    private double radius;

    public Circle() {
    }

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public String toString() {
        return "Circle{" +
                "radius=" + radius +
                '}';
    }

	//不重写报错
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}
public class Rectangle extends Graphic{
    private double length;
    private double width;
    public Rectangle(){
    }

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public String toString() {
        return "Rectangle{" +
                "length=" + length +
                ", width=" + width +
                '}';
    }
    //不重写报错
	@Override
    public double area(){
        return length * width;
    }
}
public class TestGraphic {
    public static void main(String[] args) {
        Graphic[] arr = new Graphic[2];
        arr[0] = new Circle(2.5);
        arr[1] = new Rectangle(5,3);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].area());
            /*
            arr[i]的编译时是Graphic类型,先要去Graphic类中匹配area()方法,
            此时Graphic类中没有area()方法,编译报错。
            为了编译通过,必须在Graphic类中,增加area()方法
             */
        }
    }
}

7.3 注解

7.3.1 基本注解

1、什么是注解?

在代码中,使用@开头的都是注解。


2、注解有什么用呢?

注解也是一种注释,这种注释是代码级别的注释,

它是让另一段代码来读取这个注解,并做出相应的xx操作。


例如:@Override注解。

当编译器(编译器也是一段程序)读取到某个方法上面加了@Override,

就会执行一段代码,这段代码是一段校验该方法是否满足重写要求的判断代码,

如果满足,那么编译通过,

如果不满足,编译器会报错,提醒你违反了重写的要求。


3、3个最最基本的系统注解(JDK1.8之前就有的)

(1)@Override注解

它只能加在重写的方法上面。

(2)@Deprecated注解

它可以用在方法、类、构造器等等上面。

作用:让编译器提醒程序员,如果你使用了这个方法、类、构造器等,编译器会弹出警告,

提醒你这个方法、类、构造器等已经过时了,可能存在设计的缺陷,或者其他问题,

不再推荐你继续使用。


为什么已过时的代码不修复或删掉呢?

修复:修复的成本太高,重新设计一个

   开发原则:面向修改关闭,面向扩展开发

删掉:因为这些方法、类、构造器等在旧的项目中还在使用。


   比喻:

       注销银行卡。

       不会删除你之前的所有的银行记录啥,

       而是标记为这个卡不能用。

       这个操作称为逻辑删除,不是物理删除。


(3)@SuppressWarnings

抑制警告

import java.util.Date;

public class TestDeprecated {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        Date today = new Date(2022-1900,8-1,20);
        //使用这个构造器时Date(int year, int month, int date)
        //编译器会弹出警告,说,这个方法已过时
        System.out.println(today);
        //Wed Sep 20 00:00:00 CST 3922
    }
}

7.3.2 文档注释

1、Java中有3种注释

(1)单行注释 //

(2)多行注释 /*    */

(3)文档注释/**    */


文档注释有严格的格式要求。

/**
 * 文档注释演示类
 * @author Irene
 * @version JDK1.8
 * @see java.lang.Object
 */
public class TestDoc {
    /**
     * 这是一个主方法,Java程序的入口
     * @param args String[] 它是命令行参数,可以通过java命令传入参数值。格式:java 主类名 参数值1 参数值2 ...
     */
    public static void main(String[] args) {
        //...
    }

    /**
     * 这是一个求两个整数最大值的方法
     * @param a int 第一个整数
     * @param b int 第二个整数
     * @return int 当a大于b时,返回a的值,否则返回b的值
     */
    public static int max(int a, int b){
        return a > b ? a : b;
    }

    /**
     * 这是求两个整数的商。
     * @param a int 被除数
     * @param b int 除数
     * @return int 商,a/b的结果,只有整数部分
     * @exception ArithmeticException 当b为0时可能发生算术异常
     */
    public static int divide(int a, int b){
        return a/b;
    }
}

Java学习笔记(十)_System_03

7.3.3 JUnit

说明:标准的单元测试编写方式,在实际项目中再讲。

今天,讲单元测试的JUnit的小工具只是把它当成一个代替main方法运行的小工具而已。


使用步骤:

(1)在当前模块中要引入JUnit的库

因为JUnit不是JRE核心类库的一部分,它是第三方的一个工具。

引入的方式很简单:

第一步:先写一个方法

第二步:在方法上面加一个@Test

第三步:@Test会报错,鼠标放到@Test上面,IDEA会提示我们需要引入JUnit的库(一堆class文件)

第四步:单击Add 'JUnit4' to classpath

第五步:下载,默认是下载到C盘用户目录下的.m2的仓库中

   (至于后期项目中如何依赖和下载,咱们学习Maven时再学习)


(2)凡是要独立运行的测试方法上面都可以加@Test


使用要求:

(1)自己写的类名,同一个包的所有类,包括当前类,不能命名为Test类。

(2)要使用@Test标记测试方法,

这个测试方法必须是public,void,(),非静态的

(3)@Test标记的测试方法所在类必须只有唯一的无参构造,并且也是public的。

import org.junit.Test;

public class TestJUnit {
    @Test
    public void test01(){
        System.out.println("hello");
    }

    @Test
    public void test02(){
        System.out.println("world");
    }
}

Java学习笔记(十)_静态变量_04

标签:Java,静态,笔记,class,学习,static,println,public,out
From: https://blog.51cto.com/u_16213911/7089065

相关文章

  • 怎样快速学好Java?
    怎样才能快速学好Java编程,快速接手项目开发?给大家分享6点学习经验: 1、书籍是最好的知识载体,也是进阶Java编程大神的必须工具,一定要看书 现在学习Java变得比以前容易多了,然而我要说的是,Java虽然变得越来越容易学,然而那只代表入门容易,并不代表这门编程技术就真的变简单了。如果仅仅......
  • 传热和传质基本原理-学习笔记
    传热的三种方式:传导:  不同物质形态的传导机理:  气体:气体分子的能量与其随机的平移有关,也和内部旋转和震动运动有关。可以把基于分子的随机运动的净能量传输说成是的能量扩散。       液体:与气体情况几乎相同,但流体分子靠得更近,分子间的相互作用更强,也更频繁。  ......
  • WPS RCE漏洞 学习
    复现过程2023年HW出现WPS0dayPOC影响版本:WPSOffice2023个人版<11.1.0.15120WPSOffice2019企业版<11.8.2.12085简单操作,安装指定版本以下的wps版本设置host为127.0.0.1clientweb.docer.wps.cn.cloudwps.cn在poc目录下打开cmd,启动简单的http服务......
  • Markdown学习
    一级标题二级标题引用粗体斜体中划线---分割线/***超链接无序列表姓名生日xsy2001.1.1yjj2001.1.1publicvoid......
  • Java并发编程:实现高效、线程安全的多线程应用
    Java并发编程是开发高效、可扩展的多线程应用的关键。合理地利用多线程可以提高程序的性能和响应性,但同时也会引入线程安全的问题。本文将介绍Java并发编程的关键技巧,帮助读者实现高效、线程安全的多线程应用。 线程安全的数据结构和类Java提供了许多线程安全的数据结构和类,如Co......
  • 学习之路的体会
    学习之路的体会用兴趣驱动,而不是目标驱动要因为兴趣而学习,如果你的兴趣是A,那么就去干A,并且将想要学习的与A靠拢;例如你想学好英语,同时你喜欢打游戏,那么你可以将游戏设置为英文,这时候你因为要打游戏因此会乐此不疲的去查询用到的英语单词;例如你想学好编程,同时你喜欢捣鼓一些好......
  • 编译greenDao的时候出现KaptExecution:java.lang.reflect.InvocationTargetException
    一、概述在编译greendao的时候出现了以下异常。Executionfailedfortask':common_base:kaptDebugKotlin'.>Afailureoccurredwhileexecutingorg.jetbrains.kotlin.gradle.internal.KaptExecution>java.lang.reflect.InvocationTargetException(noerrormes......
  • 8.15集训笔记
    上午测试讲题U259234累加累乘/accmul分析:直接开两个变量记录答案即可,使用for循环n次,对于s1也可以使用等差数列求和公式。点击查看代码#include<bits/stdc++.h>usingnamespacestd;intn;intmain(){cin>>n;ints1=0,s2=1;for(inti=1;i<=n;i++){......
  • 【刷题笔记】22. Generate Parentheses
    题目Given n pairsofparentheses,writeafunctiontogenerateallcombinationsofwell-formedparentheses.Forexample,given n =3,asolutionsetis:["((()))","(()())","(())()","()(())","()()(......
  • Programming abstractions in C阅读笔记p111-p113: boilerplate
    《ProgrammingAbstractionsInC》学习第47天,p111-p113,总结如下:一、技术总结1.boilerplate/**File:random.h*Version:1.0*LastmodifiedonFriJul2216:44:361994byeroberts*-----------------------------------------------------*Thisinterfacepr......