JAVA学习笔记

最新推荐文章于 2024-05-13 21:50:21 发布
最新推荐文章于 2024-05-13 21:50:21 发布
阅读量157 收藏 1
点赞数
文章标签： java 类 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39542170/article/details/111875020
版权

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=153
本人系统：win10
使用软件：IntelliJ IDEA 2020.3 x64

基本知识点：

【命名】

遵守驼峰命名方式 （SystemService 、UserService 、CustomerService）
*类名、接口名:首字母大写，后面每个单词首字母大写。
*变量名、方法名:首字母小写，后面每个单词首字母大写。
*常量名:全部大写

【注释】

单行注释：//
多行注释：/* * /
文档注释：/** * /

【数据类型】
在这里插入图片描述
类型转换：

byte i = 1 ;
int j = 10245;
i = (byte) j;

【运算符】

！ 非
^ 异或
&& 短路与

【字符串连接】

a=100; b = 200;
System. out. print1n(a + ”+" + b + ”=" + (a+b));

【控制语句】
if

if( x == 10 ){
System.out.print(“Value of X is 10”);
}
else if( x == 20 ){
System.out.print(“Value of X is 20”);
}
else if( x == 30 ){
System.out.print(“Value of X is 30”);
}
else{
System.out.print(“这是 else 语句”);
}

for

for(int number=1;number<=5;number++){
result*=number;
}

while

while(i <= 10) {
n=n*i;
i++;
}

【helloword解释】

	// public表示公开的，在任何位置都是可以访问的
    // static表示静态的，使用“类名.”的方式即可访问,不需要创建对象，就可以调用main方法
    // void表示main方法执行结束之后不返回任何值
    // main是main方法的方法名
    // (String[] args) 是main方法的形式参数列表
class HelloChina{ 
	public static void main(String[] args){ 
		System.out.println("Hello!");  
	}
}

1、类体中不可以写java语句，声明变量除外
2、Java语句要加分号
3、main 主方法，是程序运行的入口
4、public class 和class的区别:
一个java源文件当中可以定义多个class
一个java源文件当中publ1c的class不是必须的
一个class会定义生成- -个xxx . class字节码文件
一个java源文件当中定义公开的类的话，只能有一个，并且该英名称必须和java源文件名称一致。

类和对象

public class OOTest {
	public static void main(String[] args) {
		 student s = new student(); // 创建
		 s.addr = new address(); // 创建
		 int a = s.age;
		 s.sex = true;
		 boolean se = s.sex;
		 
		 System.out.println("年龄 = " + a );
		 System.out.println("性别 = " + se );
		 System.out.println("姓名 = " + s.name );
		 System.out.println( s.name + " is from " + s.addr.country);
	}
}

// 定义类
class  student{
	int age;
	string name ;
	boolean sex;
	String name = "zyy";
	address addr ; // address 类型的变量
}

class address{
	String country = "China";
	String city;
	String street;
	int code;
}

方法

package com.atz;

public class Test01 {
    public static void main(String[] args){
        User u = new User(20); // u 不是变量 ，而是指针
        add2(u); // 传的是地址，改变原有的值
        System.out.println("main-->"+u.age);
    }

    public static void add(int i) {
        i ++; // 传的是字面值，只改形参，不改变原来的 i
        System.out.println("add -->"+i);
    }

    public static void add2(User u) {
        u.age ++;
        System.out.println("add -->"+u.age);  // i 是局部变量，不改变main里的i
    }
}

class User{
    int age;

    // 构造方法
    public User(int i){
        age = i;
    }
}

方法重载

overload
在同一个类当中方法名相同，
参数列表不同:类型、顺序、个数
方法的返回类型可以相同也可以不相同。

public class Demo {
	public void add(){
		//method body
	}

	public void add(int a){
		//method body
	}
	
	public int add(int a,int b){
		//method body
		return 0;
	}
}

访问控制权限

1、修饰类、变量、方法
2、
public 公开的，任何位置都可以访问
private 私有的，只在本类中访问
protected 同包、子类可以访问
缺省的 同包可以访问
3、修饰符的范围:
private <缺省< protected < public

final 关键字

1、final是-个关键字，表示最终的,不可变的。
2、final修饰的类无法被继承 修饰的方法无法被覆盖
3、final修饰的变量一旦手动赋值之 后，不可重新赋值
4、final修饰的实例变量，必须手动赋值
5、final修饰的引用，public static final String GUO_JIA = “China” , 作常量用,静态（没对象）不可变

public class FinalTest {
    public static void main(String[] args){
        final int k = 100;
        // k = 200; // 报错
        // final int i; // 报错,要给初始值

        Data d = new Data();
        // 变成垃圾数据。等待垃圾回收器回收
        d = new Data(2020,5,12);
        final Data d2 = new Data(2020,50,13); // 地址不能变
        d2.test = 50;
        System.out.println(d2.test); // 但是能改变内容
    }
}

public class Data {
    private int year;
    private int month;
    private int day;
    public int test = 1;
    protected int pro = 2;
    int quesheng = 2;

    public Data(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public Data(){
        /* 代码重复,调用
        this.year = 1997;
        this.month = 11;
        this.day = 3;
        */
        // this方法只能在第一行
        this(1997,11,3); // 不会创建新的对象，记住就行
    }

    public void print(){
        System.out.println(this.year + "-" + this.month + "-" +this.day );
    }

    public void show(){
        System.out.println("Father class data is working!!!");
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }
}

封装、继承、多态

1、封装

package com.atz;
/* 面向对象的封装性 */
public class Student01 {
    // 属性私有化，set get
    private int id;
    private int age ;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    void setAge(int a){
        if(a < 0 | a> 150){
            System.out.println("输入的年龄错误");
            return;
        }
        age = a;
    }

    int getAge(){
        return age;
    }
}

封装后需要get、set函数来获取、改变内部变量
在这里插入图片描述
在这里插入图片描述
this 关键字
this 用法综合测试

package com.atzyy1222;

public class Test {
    int i = 10;

    public static void main(String[] args){
        // 调用method1
        // 完整方式
        // 省略方式

        // 调用method2 ？？？
        // 完整方式
        // 省略方式, 无
    }


    public static void method1(){
        // 调用 jump
        // 完整方式
        // 省略方式

        // 调用 run, 实例方法先实例化
        // 完整方式 ?
        // 省略方式，无

        // 访问i
        // 完整方式
        // 省略方式
    }

    public void method2(){
        // 调用 jump
        // 完整方式
        // 省略方式

        // 调用 run
        // 完整方式
        // 省略方式


        // 访问i
        // 完整方式
        // 省略方式

    }

    public static void jump(){
        System.out.println("static jump");
    }

    public void run(){
        System.out.println("no static run");
    }
}

this 用法综合答案

package com.atz1222;

public class TestAnswer {
    int i = 10;

    public static void main(String[] args){
        // 调用method1
        // 完整方式
        TestAnswer.method1();
        // 省略方式
        method1();

        // 调用method2 ？？？
        // 完整方式
        TestAnswer t = new TestAnswer(); // 没有对象，创建对象
        t.method2();
        // 省略方式, 无
    }

    public static void method1(){
        // 调用 jump
        // 完整方式
        TestAnswer.jump();
        // 省略方式
        jump();

        // 调用 run, 实例方法先实例化
        // 完整方式 ?
        TestAnswer t = new TestAnswer();
        t.run();
        // 省略方式，无

        // 访问i
        // 完整方式
        System.out.println(t.i);
        // 省略方式
    }

    public void method2(){
        // 调用 jump
        // 完整方式
        TestAnswer.jump();
        // 省略方式
        jump();

        // 调用 run
        // 完整方式
        this.run(); // 本身有对象
        // 省略方式
        run();

        // 访问i
        // 完整方式
        System.out.println(this.i);
        // 省略方式
        System.out.println(i);
    }

    public static void jump(){
        System.out.println("static jump");
    }

    public void run(){
        System.out.println("no static run");
    }
}

this用法2

public class Data {
    private int year;
    private int month;
    private int day;
    public int test = 1;
    protected int pro = 2;
    int quesheng = 2;

    public Data(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public Data(){
        /* 代码重复,调用
        this.year = 1997;
        this.month = 11;
        this.day = 3;
        */
        // this方法只能在第一行
        this(1997,11,3); // 不会创建新的对象，记住就行
    }
}

this可以用在哪里:
1、可以使用在实例方法当中，代表当前对象[语法格式: this.]
2、可以使用在构造方法当中，通过当前的构造方法调用其它的构造方法[语法格式: this (实参) ;]

无static = 实例 = 对象参与
静态中无法直接访问实例，也没有this
静态可直接通过类名去调用

2、继承

1、实质：代码复用
2、继承语法格式:
[修饰符列表] class 类名extends父类名{
类体-属性+方法
}
3、不支持继承：私有的、构造方法
4、java语言中假设一个类没有 显示的继承任何类，该类默认继承JavaSE库当中提供的java。lang。object类。

方法覆盖

override/overwrite
当父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重新编写，
【注意】
1、返回值类型相同，方法名相同，形參列表相同，建议复制粘贴
2、访问权限不能更低，只能更高
3、不能继承的不能覆盖
4、静态方法不存在覆盖

public class OverrideTest {
    public static void main(String[] args){
        Animal a = new Animal();
        Cat b = new Cat();
        MeiDuan c = new MeiDuan();
        a.move();
        b.move();
        c.move();
    }
}

public class Animal {
    public int age = 2;
    public void move (){ // static方法不能覆盖
        System.out.println("动物在移动");
    }
    public void eat(){
        System.out.println("mia mia mia");
    }
}

public class Cat extends Animal{
    public void move (){
        System.out.println("小猫咪在走路o(*￣▽￣*)o");
    }

    // 子类特有的行为
    public void catchRat(){
        System.out.println("小猫咪在抓老鼠");
    }

    public void eat(){
        System.out.println("猫：mia mia mia");
    }
}

public class MeiDuan extends Cat{
    @Override
    public void move() {
        // super.move();
        System.out.println("美短GOGOGO！！");
    }
}

结果：

动物在移动
小猫咪在走路o(￣▽￣)o
美短GOGOGO！！

3、多态

向上转型(upcasting)，子变父
向下转型(dowmcasting)，父变子

public class DuoTaiTest {
    public static void main(String[] args) {
        Animal a = new Cat(); // 向上转型
        a.move(); // cat的move,内容是Cat,框架是Animal
        // a.catchRat();  无子类特有方法

        Cat c1 = (Cat) a;// 向下转型，存在隐患，可以编译但无法运行 
        				 //如 bird 不能转成 cat,无继承关系。
        c1.move();
        c1.catchRat();

        Animal a2 = new Bird();
        
        // instanceof 可避免向下转型出现的 ClassCastException
        if(a2 instanceof Cat){ // a是Cat的实例
            Cat c = (Cat) a2;
            c.catchRat();
        }
        else if (a2 instanceof Bird){
            Bird b = (Bird) a2;
            b.fly();
        }
    }
}

两个对象

public class DuoTaiTest2 {
    public static void main(String[] args){
        Master m = new Master();
        Cat c = new Cat();
        m.feed(c);

        Bird b = new Bird();
        m.feed(b);

        System.out.println(b instanceof Animal);
    }
}

public class Master {
    // Master和Cat、Bird这两个类型的关联程度很强，耦合度很高,扩展力差。
    /*
    public void feed(Cat c) {
        System.out.println("主人扔了一只鱼");
        c.eat();
    }

    public void feed(Bird b) {
        System.out.println("主人扔了不知道什么东西");
        b.eat();
    }*/
    // Master 直接面对他们的父类，耦合度高
    public void feed(Animal a){
        System.out.println("主人扔了不知道什么东西");
        a.eat();
    }
}
YY_oot
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java学习笔记
11-21
Java学习笔记 1、连接数据库步骤 2、不同数据库的驱动程序和连接字符串 3、连接数据库常见问题 4、B/S结构和C/S结构的区别 5、如何处理中文乱码问题 6、使用JavaMail发送注册验证邮件 7、不安全的用户名密码验证 8、...
java学习笔记
12-22
构造方法6. Java Bean常用API第一部分1.引用类型的使用步骤2.Scanner类3.匿名对象4.Random类5.ArrayList集合5.String类6.static关键字7.Arrays数组工具类8.Math数学工具类继承与多态1.继承2.抽象类3.接口4.多态5....
Java 学习笔记
最新发布
weixin_42098295的博客
05-13 1958
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7370
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 1708
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
JAVA学习笔记：目录
任性的生鱼片 的博客
12-28 1946
目录 java学习笔记1：了解java、JDK、JRE、JVM java学习笔记2：JDK下载和安装以及测试控制台测试是否配置成功 java学习笔记3：用记事本写第一个java程序，第一个java程序常见错误总结，第一个java程序详细解析 java学习笔记4：常见的DOS命令和java开发工具 java学习笔记5：eclipse的下载及使用，以及java程序的运行 java学习笔记6：注释、标识...
Java学习笔记目录索引 (持续更新中)
热门推荐
Guizy
01-15 12万+
Java学习路线目录索引 一、Java基础(省略) Lambda表达式及函数式接口 二、Java数据库 MySQL 一 概念、DDL、DML、DQL、事务、约束等 数据库设计 一 多表关系、三大范式 JDBC 一 基本使用、DAO组件、连接池、JDBCTemplate 三、JavaWeb HTML相关学习 CSS — 常用属性 CSS — 选择器及三大特性 CSS — 网页的布局方式 C...........................
Java学习笔记一
u013033706的博客
10-23 1457
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1000
Java 学习笔记：面向对象
Java 学习笔记(手写版)
心海非海_のBlog
10-25 2416
Java 学习笔记(手写版) 文章目录Java 学习笔记(手写版)变量控制流程包机制 & 用户交互 Scanner方法（函数） & 驼峰命名法递归 & 数组OOP & 构造器封装继承 （super & this）方法重写 静态方法 & 非静态方法多态 & instance of & 类型转换static 关键字抽象类接口 & 实现类内部类正则表达式异常注解反射//..多线程基本概念线程创建静态代理模式 & 函数式接口 &amp
java学习笔记总结
04-02
自己几个月的学习总结，一些解决问题的办法，很实用，希望对大家有所帮助！
java学习笔记资源合集
05-25
java学习笔记 Java 自 1995 年诞生，至今有 16 年的历史，从诞生之日起，逐渐被广泛接受并成为推 动了 web 迅速发展。Java 的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。 Java 最大的特点是平台无关性...
Java学习笔记学习笔记
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
java学习笔记markdown
03-12
狂神说java学习笔记，markdown版
java学习笔记java学习笔记java学习笔记java学习笔记
07-31
java学习笔记
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
java 学习笔记 xmind
01-02
Java 学习笔记 XMind 是一款专门用于整理和管理 Java 学习内容的思维导图软件。通过 XMind，我们可以将 Java 相关的知识点、重点、代码案例、类库等内容进行整理和分类，方便我们进行学习和复习。 首先，我用 XMind...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值