Java学习

最新推荐文章于 2023-09-15 08:11:52 发布

X_lywfc

最新推荐文章于 2023-09-15 08:11:52 发布

阅读量97

点赞数

分类专栏： Java 文章标签： learn

本文链接：https://blog.csdn.net/X_lywfc/article/details/100762827

版权

Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

public class Welcome {

//第一部分	Java入门
public static void main(String[] args){

// 1. 第一个Java程序

System.out.println("hello world!");

// 2.Java方法

// 3.Java构造函数

// 4.Java访问修饰符-public，protected，private，default

public 公开对外部可见
private 在类的内部可见
protected 对包和所有子类可见
无关键字（不指定修饰符）对包可见，不需要修饰符

<1.>无关键字
默认访问修饰是指没有为类，字段，方法等显式声明访问修饰符。声明没有任何访问控制修饰符的变量或方法可用于同一包中的任何其他类。接口中的字段隐式为public static final，接口中的方法默认为public。

<2.>private

变量和构造函数只能在声明的类中访问
限制性最强的访问级别。类和接口不能声明为private

如果类中存在公共get方法，则可以在类中将变量声明为private。使用private修饰符是对象封装自身并隐藏来自外部世界的数据的主要方式。

public class Logger {
        private String format;
     
    public String getFormat() {
       return this.format;
    }
 
    public void setFormat(String format) {
       this.format = format;
    }
 }

这里，Logger类的format变量是private，因此其他类无法直接检索或设置它的值。
因此，为了使这个变量对外界可用，Logger类中定义了两个公共方法：getFormat()用于返回format的值，setFormat(String)用于设置它的值。

❤️.>protected

-方法，字段可以声明为protected 但是接口中的方法和字段不能声明为protected

// 5.Java if else if else

		int age=10;
		if(age>18){
			System.out .print("年龄超过18岁！");
		}
		else{
			System.out.print("未成年！");
		}

// 6.Java switch case

int num=50;
switch(num){
	case 10:
	System.out.println("10");
	break;
	case 20:
	System.out.println("20");
	break;
	default:
		System.out.println("Not in those！");
}

// 7.Java for循环

int arr[]={
		12,23,11,35
	};
	for(int i:arr){
	System.out.println(i);
}
		
		
//		打断循环
		
	aa: for (int i = 1; i <= 3; i++) {
        bb: for (int j = 1; j <= 3; j++) {
            if (i == 2 && j == 2) {
                break aa;
            }
           System.out.println(i + " " + j);
        }
    }


	2.

aa: for (int i = 1; i <= 3; i++) {
    bb: for (int j = 1; j <= 3; j++) {
        if (i == 2 && j == 2) {
            break bb;
        }
        System.out.println(i + " " + j);
    }
}

	
//		无限循环
	
	for (;;) {
       System.out.println("infinitive loop");
    }

// 8.Java while循环

int i=1;
	while (i<=10){
		System.out.println(i);
		i++;
	}

// 9.Java do。。。while循环

int i=1;
 do{
		System.out.println(i);
		i++;
	}while(i<=10);

// 10.Java static关键字

用于–内存管理
应用于----变量（也称类变量），方法（类方法），代码块，嵌套类
注意：static属于类，而不是类的实例

<1.>java静态变量

用于引用所有对象的公共属性（对于每个对象不是唯一的）。如：员工公司名称，学生的大学名称
优点:使程序存储器高效（节省内存）

理解不使用静态变量的问题

class Student{  
     int rollno;  
     String name;  
     String college="ITS";  
}

假设在一所学校有500名学生，现在所有实例数据成员将在每次创建对象时获取内存。所有学生都有其唯一的注册ID：rollno和　name ，因此实例数据成员没有什么问题。college 指的是所有对象的共同属性。如果使它静态化(使用static关键字修饲)，这个字段将只获得内存一次。

	Java静态属性被共享给所有对象

静态变量示例

		//Program of static variable  

class Student8 {
    int rollno;
    String name;
    static String college = "ITS";

    Student8(int r, String n) {
        rollno = r;
        name = n;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + college);
    }

    public static void main(String args[]) {
        Student8 s1 = new Student8(111, "Karan");
        Student8 s2 = new Student8(222, "Aryan");

        s1.display();
        s2.display();
    }
}

执行结果：

	111 Karan ITS
    222 Aryan ITS

在这里插入图片描述
不使用静态变量的计数器程序
在这个例子中，我们创建了一个名为count的实例变量用来统计创建对象的数目，它在构造函数中执行递增。由于实例变量在创建对象时要获取内存，每个对象都将具有实例变量的副本，如果它被递增了，它也不会反映到其他对象中。所以每个对象在count变量中的值还是1

class Counter {
    int count = 0;// will get memory when instance is created

    Counter() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();

    }
}

执行结果：

1
1
1

计数器静态变量的程序

如上所述，静态变量将只获取一次内存，如果任何对象更改静态变量的值，它将保留其值，所有实例均可访问同一变量值。

class Counter2 {
    static int count = 0;// will get memory only once and retain its value

    Counter2() {
        count++;
        System.out.println(count);
    }

    public static void main(String args[]) {

        Counter2 c1 = new Counter2();
        Counter2 c2 = new Counter2();
        Counter2 c3 = new Counter2();

    }
}

执行结果：

1
2
3

<2.>java 静态方法

如果在任何方法上应用static关键字，此方法称为静态方法。

静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

静态方法的示例

//Program of changing the common property of all objects(static field).  

class Student9 {
    int rollno;
    String name;
    static String college = "ITS";

    static void change() {
        college = "BBDIT";
    }

    Student9(int r, String n) {
        rollno = r;
        name = n;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + college);
    }

    public static void main(String args[]) {
        Student9.change();

        Student9 s1 = new Student9(111, "Karan");
        Student9 s2 = new Student9(222, "Aryan");
        Student9 s3 = new Student9(333, "Sonoo");

        s1.display();
        s2.display();
        s3.display();
    }
}

执行结果：

111 Karan BBDIT
222 Aryan BBDIT
333 Sonoo BBDIT

执行正常计算的静态方法的另一个示例:

//Program to get cube of a given number by static method  

class Calculate {
    static int cube(int x) {
        return x * x * x;
    }

    public static void main(String args[]) {
        int result = Calculate.cube(5);
        System.out.println(result);
    }
}

执行结果：

静态方法的限制

静态方法不能直接使用非静态数据成员或调用非静态方法。
this和super两个关键字不能在静态上下文中使用

class A {
int a = 40;// non static
```
 public static void main(String args[]) {
     System.out.println(a);
 }
```
}

执行结果：

[编译错误！]Compile Time Error

为什么java main方法是静态的？
这是因为对象不需要调用静态方法，如果它是非静态方法，jvm首先要创建对象，然后调用main()方法，这将导致额外的内存分配的问题。

❤️.>java 静态类

初始化静态数据成员
在类加载时在main方法之前执行

静态块的示例

class A2 {
    static {
        System.out.println("static block is invoked");
    }

    public static void main(String args[]) {
        System.out.println("Hello main");
    }
}

执行结果：

static block is invoked
Hello main

可以执行程序没有main（）方法吗？
key:可以，一种方法是静态块，但是在以前就JDK版本中，不是在JDK1.7中。

class A3 {
    static {
        System.out.println("static block is invoked");
        System.exit(0);
    }
}

执行结果：

static block is invoked

在JDK7及以上的版本中，输出为;

错误: 在类 Main 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)

// 11.Java break关键字

for (int i = 1; i <= 10; i++) {
        if (i == 5) {
           break;
        }
        System.out.println(i);
    }

// 12.Java continue语句关键字

for (int i = 1; i <= 10; i++) {
       if (i == 5) {
            continue;
        }
        System.out.println(i);
    }

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

// 第二部分面向对象的概念

java继承
继承可以定义为一个类获取另一个类的属性(方法和字段)的过程。通过使用继承，可以按层次顺序管理信息。

继承其他类的属性的类称为子类(或派生类)，被其它继承其属性的类称为超类(或基类，父类)。

.1.关键字：extends
语法:

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

示例：

// 文件：MyCalculation.java
class Calculation {
    int z;

    public void addition(int x, int y) {
        z = x + y;
        System.out.println("两个数的和是:" + z);
    }

    public void Subtraction(int x, int y) {
        z = x - y;
        System.out.println("两个数的差是:" + z);
    }
}

public class MyCalculation extends Calculation {
    public void multiplication(int x, int y) {
        z = x * y;
        System.out.println("两个数的乘积是:" + z);
    }

    public static void main(String args[]) {
        int a = 20, b = 10;
        MyCalculation demo = new MyCalculation();
        demo.addition(a, b);
        demo.Subtraction(a, b);
        demo.multiplication(a, b);
    }
}

.2.super关键字

区分成员
如果一个类继承了另一个类的属性。如果超类的成员具有与子类相同的名称，要区分这些变量，使用super关键字显示地访问父类的属性，如下所示 -

super.variable; // 访问父类变量
super.method();// 访问父类方法

示例

// Subclass.java
class Superclass {
    int num = 20;

    // 超类方法
    public void display() {
        System.out.println("这是超类的显示方法");
    }
}

public class Subclass extends Superclass {
    int num = 10;

    // 子类方法
    public void display() {
        System.out.println("这是子类的显示方法");
    }

    public void my_method() {
        // 初始化子类
        Subclass sub = new Subclass();

        // 调用子类的display()方法
        sub.display();

        // 调用父类的display()方法
        super.display();

        // 打印子类变量num的值
        System.out.println("子类中名为num的变量的值:" + sub.num);

        // 打印父类变量num的值
        System.out.println("超类中名为num的变量的值:" + super.num);
    }

    public static void main(String args[]) {
        Subclass obj = new Subclass();
        obj.my_method();
    }
}

执行结果：

这是子类的显示方法
这是超类的显示方法
子类中名为num的变量的值:10
超类中名为num的变量的值:20

.3.调用父类构造函数

super(parm-values);

示例：

// Subclass.java
class Superclass {
    int age;

    Superclass(int age) {
        this.age = age;
    }

    public void getAge() {
        System.out.println("超类中名为age的变量的值是: " + age);
    }
}

public class Subclass extends Superclass {
    Subclass(int age) {
        super(age);
    }

    public static void main(String argd[]) {
        Subclass s = new Subclass(24);
        s.getAge();
    }
}

执行结果:

超类中名为age的变量的值是: 24

// 第三部分数据类型和运算符

// 第四部分接口和抽象类

// 第五部分字符串操作

面试问题：为什么String在Java中是不可变的？

String是任何编程语言中最常用的类之一。String是Java中的不可变和final。Java运行时环境维护一个String池，使得String成为一个特殊的类。

Java运行环境可以节省大量的堆空间，因为不同的string变量可以引用池中的相同string变量
更为安全。数据库用户名作为string传递以获取数据库连接，并套接字编程之和端口详细信息中作为string传递，由于string是不可变的，因此无法更改其值。
对于多线程是安全的。可以跨不同的线程共享单个string实例。这样避免了使用同步来保证线程安全。字符串是隐式线程安全的。
创建时缓存它的哈希码，不需要再次计算。使其处理速度比其他hashmap键对象快

string转换为char

	public class StringToCharJava {

    public static void main(String[] args) {
        String str = "qwerty.com";

        // 字符串转到字符
        char[] chars = str.toCharArray();
        System.out.println(chars.length);

        // 指定索引处字符
        char c = str.charAt(2);
        System.out.println(c);

        // 字符串转到字符数组
        char[] chars1 = new char[7];
        str.getChars(0, 7, chars1, 0);
        System.out.println(chars1);

    }
}

执行结果：

    10
     e
	qwerty.

string 拆分

public String[] split(String regex)方法

String s = "abcaada";
System.out.println(Arrays.toString(s.split("a")));

实际上通过limit参数使用0传递来使用第二种方法。

public String[] split(String regex) {
    return split(regex, 0);
}

public String[] split(String regex, int limit)方法

String s = "Haikou,Hainan,China";
String[] data = s.split(",", 2);
System.out.println("Name = "+data[0]); //Haikou
System.out.println("Address = "+data[1]); //Hainan,China

示例

import java.util.Arrays;

public class JavaStringSplit {

    /**
     * Java String split example
     * 
     * @param args
     */
    public static void main(String[] args) {
        String line = "Copyright of yiibai.com at 2099";

        String[] words = line.split(" ");

        String[] twoWords = line.split(" ", 2);

        System.out.println("String split with delimiter: " + Arrays.toString(words));

        System.out.println("String split into two: " + Arrays.toString(twoWords));

        // 用特殊字符分隔的拆分字符串
        String wordsWithNumbers = "I|am|a|java|developer";

        String[] numbers = wordsWithNumbers.split("\\|");

        System.out.println("String split with special character: " + Arrays.toString(numbers));

    }
}

执行结果：

String split with delimiter: [Copyright, of, yiibai.com, at, 2099]
String split into two: [Copyright, of yiibai.com at 2099]
String split with special character: [I, am, a, java, developer]

string与char数组互转
string 转为char数组

import java.util.Arrays;

public class StringToCharArray {

    public static void main(String[] args) {
        String str = "qqqqqq.com";
        char[] charArr = str.toCharArray();
        // print the char[] elements
        System.out.println("String converted to char array: " + Arrays.toString(charArr));
    }
}

执行结果

String converted to char array: [q, q,q, q, q, q, ., c, o, m]

char数组转为string

import java.util.Arrays;

public class CharArrayToString {

    public static void main(String[] args) {
        char[] charArray = { 'q', 'q', 'q', 'q', 'q', '.', 'C', 'O', 'M' };
        String str = new String(charArray);

        System.out.println(str);
    }
}

执行结果：

qqqqqq.COM

字符串连接

stringbuffer
stringbuilder

使用“+”

import java.util.Arrays;

public class StringToCharArray {

    public static void main(String args[]) {
        String str = new String("sdafg");
        str += "fshrsehr";
    }
}

使用stringbuffer

public class StringConcatenationExample {

    public static void main(String args[]){
         StringBuffer str = new StringBuffer ("Yiibai");
         str.append("kaops!!");
    }

}

使用 + 运算符字符串连接的解释：
以下是使用+运算符进行字符串连接所涉及的步骤：

创建一个新的StringBuilder对象；
将字符串"afeaef"复制到新创建的StringBuilder对象；
调用StringBuilder append()方法将sdagag附加到对象；
调用StringBuilder toString()方法来获取String对象；
新的String对象引用分配给str，旧的字符串"dsagagr"可用于垃圾回收。

使用append字符串连接的解释
如果使用StringBuffer或StringBuilder对象，则按以下步骤完成：

创建一个新的StringBuffer对象，值为"dsghsge"；
调用append()方法将"frehtesehhfsh"附加到对象；
调用StringBuffer toString()方法来获取String对象；

比较之下，第二种方式耗时更少，使用更少的资源并产生更少的垃圾收集。

String，StringBuffer和StringBuilder区别

string：
String类表示字符串，可以通过两种方式实例化String。

String str = "abc";
// 或者
String str = new String ("abc");

string stringbuffer stringbuilder

String是不可变的，而StringBuffer和StringBuider是可变类。
StringBuffer是线程安全和同步的，而StringBuilder不是，因引StringBuilder比StringBuffer更快。
String 连接 + 操作符在内部使用StringBuffer或StringBuilder类。
对于非多线程环境中的String操作，应该使用StringBuilder，否则使用StringBuffer类。

}

X_lywfc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习

public class Welcome {//第一部分 Java入门public static void main(String[] args){// 1. 第一个Java程序System.out.println("hello world!");// 2.Java方法// 3.Java构造函数// 4.Java访问修饰符-public，protected，private...
复制链接

扫一扫